aede2ea203
* Converted ParcelAccessEntry.Flags to AccessList enum git-svn-id: http://libopenmetaverse.googlecode.com/svn/libopenmetaverse/trunk@2359 52acb1d6-8a22-11de-b505-999d5b087335
80249 lines
2.9 MiB
80249 lines
2.9 MiB
/*
|
|
* Copyright (c) 2008, 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 Second Life Reverse Engineering Team 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.Text;
|
|
using OpenMetaverse;
|
|
|
|
namespace OpenMetaverse.Packets
|
|
{
|
|
/// <summary>
|
|
/// Thrown when a packet could not be successfully deserialized
|
|
/// </summary>
|
|
public class MalformedDataException : ApplicationException
|
|
{
|
|
/// <summary>
|
|
/// Default constructor
|
|
/// </summary>
|
|
public MalformedDataException() { }
|
|
|
|
/// <summary>
|
|
/// Constructor that takes an additional error message
|
|
/// </summary>
|
|
/// <param name="Message">An error message to attach to this exception</param>
|
|
public MalformedDataException(string Message)
|
|
: base(Message)
|
|
{
|
|
this.Source = "Packet decoding";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The header of a message template packet. Either 5, 6, or 8 bytes in
|
|
/// length at the beginning of the packet, and encapsulates any
|
|
/// appended ACKs at the end of the packet as well
|
|
/// </summary>
|
|
public abstract class Header
|
|
{
|
|
/// <summary>Raw header data, does not include appended ACKs</summary>
|
|
public byte[] Data;
|
|
/// <summary>Raw value of the flags byte</summary>
|
|
public byte Flags
|
|
{
|
|
get { return Data[0]; }
|
|
set { Data[0] = value; }
|
|
}
|
|
/// <summary>Reliable flag, whether this packet requires an ACK</summary>
|
|
public bool Reliable
|
|
{
|
|
get { return (Data[0] & Helpers.MSG_RELIABLE) != 0; }
|
|
set { if (value) { Data[0] |= (byte)Helpers.MSG_RELIABLE; } else { byte mask = (byte)Helpers.MSG_RELIABLE ^ 0xFF; Data[0] &= mask; } }
|
|
}
|
|
/// <summary>Resent flag, whether this same packet has already been
|
|
/// sent</summary>
|
|
public bool Resent
|
|
{
|
|
get { return (Data[0] & Helpers.MSG_RESENT) != 0; }
|
|
set { if (value) { Data[0] |= (byte)Helpers.MSG_RESENT; } else { byte mask = (byte)Helpers.MSG_RESENT ^ 0xFF; Data[0] &= mask; } }
|
|
}
|
|
/// <summary>Zerocoded flag, whether this packet is compressed with
|
|
/// zerocoding</summary>
|
|
public bool Zerocoded
|
|
{
|
|
get { return (Data[0] & Helpers.MSG_ZEROCODED) != 0; }
|
|
set { if (value) { Data[0] |= (byte)Helpers.MSG_ZEROCODED; } else { byte mask = (byte)Helpers.MSG_ZEROCODED ^ 0xFF; Data[0] &= mask; } }
|
|
}
|
|
/// <summary>Appended ACKs flag, whether this packet has ACKs appended
|
|
/// to the end</summary>
|
|
public bool AppendedAcks
|
|
{
|
|
get { return (Data[0] & Helpers.MSG_APPENDED_ACKS) != 0; }
|
|
set { if (value) { Data[0] |= (byte)Helpers.MSG_APPENDED_ACKS; } else { byte mask = (byte)Helpers.MSG_APPENDED_ACKS ^ 0xFF; Data[0] &= mask; } }
|
|
}
|
|
/// <summary>Packet sequence number</summary>
|
|
public uint Sequence
|
|
{
|
|
get { return (uint)((Data[1] << 24) + (Data[2] << 16) + (Data[3] << 8) + Data[4]); }
|
|
set
|
|
{
|
|
Data[1] = (byte)(value >> 24); Data[2] = (byte)(value >> 16);
|
|
Data[3] = (byte)(value >> 8); Data[4] = (byte)(value % 256);
|
|
}
|
|
}
|
|
/// <summary>Numeric ID number of this packet</summary>
|
|
public abstract ushort ID { get; set; }
|
|
/// <summary>Frequency classification of this packet, Low Medium or
|
|
/// High</summary>
|
|
public abstract PacketFrequency Frequency { get; }
|
|
/// <summary>Convert this header to a byte array, not including any
|
|
/// appended ACKs</summary>
|
|
public abstract void ToBytes(byte[] bytes, ref int i);
|
|
/// <summary>Array containing all the appended ACKs of this packet</summary>
|
|
public uint[] AckList;
|
|
|
|
public abstract void FromBytes(byte[] bytes, ref int pos, ref int packetEnd);
|
|
|
|
/// <summary>
|
|
/// Convert the AckList to a byte array, used for packet serializing
|
|
/// </summary>
|
|
/// <param name="bytes">Reference to the target byte array</param>
|
|
/// <param name="i">Beginning position to start writing to in the byte
|
|
/// array, will be updated with the ending position of the ACK list</param>
|
|
public void AcksToBytes(byte[] bytes, ref int i)
|
|
{
|
|
foreach (uint ack in AckList)
|
|
{
|
|
bytes[i++] = (byte)((ack >> 24) % 256);
|
|
bytes[i++] = (byte)((ack >> 16) % 256);
|
|
bytes[i++] = (byte)((ack >> 8) % 256);
|
|
bytes[i++] = (byte)(ack % 256);
|
|
}
|
|
if (AckList.Length > 0) { bytes[i++] = (byte)AckList.Length; }
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="pos"></param>
|
|
/// <param name="packetEnd"></param>
|
|
/// <returns></returns>
|
|
public static Header BuildHeader(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
if (bytes[6] == 0xFF)
|
|
{
|
|
if (bytes[7] == 0xFF)
|
|
{
|
|
return new LowHeader(bytes, ref pos, ref packetEnd);
|
|
}
|
|
else
|
|
{
|
|
return new MediumHeader(bytes, ref pos, ref packetEnd);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return new HighHeader(bytes, ref pos, ref packetEnd);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="packetEnd"></param>
|
|
protected void CreateAckList(byte[] bytes, ref int packetEnd)
|
|
{
|
|
if (AppendedAcks)
|
|
{
|
|
try
|
|
{
|
|
int count = bytes[packetEnd--];
|
|
AckList = new uint[count];
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
AckList[i] = (uint)(
|
|
(bytes[(packetEnd - i * 4) - 3] << 24) |
|
|
(bytes[(packetEnd - i * 4) - 2] << 16) |
|
|
(bytes[(packetEnd - i * 4) - 1] << 8) |
|
|
(bytes[(packetEnd - i * 4) ]));
|
|
}
|
|
|
|
packetEnd -= (count * 4);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
AckList = new uint[0];
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AckList = new uint[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public class LowHeader : Header
|
|
{
|
|
/// <summary></summary>
|
|
public override ushort ID
|
|
{
|
|
get { return (ushort)((Data[8] << 8) + Data[9]); }
|
|
set { Data[8] = (byte)(value >> 8); Data[9] = (byte)(value % 256); }
|
|
}
|
|
/// <summary></summary>
|
|
public override PacketFrequency Frequency { get { return PacketFrequency.Low; } }
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public LowHeader()
|
|
{
|
|
Data = new byte[10];
|
|
Data[6] = Data[7] = 0xFF;
|
|
AckList = new uint[0];
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="pos"></param>
|
|
/// <param name="packetEnd"></param>
|
|
public LowHeader(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
FromBytes(bytes, ref pos, ref packetEnd);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
if (bytes.Length < 10) { throw new MalformedDataException(); }
|
|
Data = new byte[10];
|
|
Buffer.BlockCopy(bytes, 0, Data, 0, 10);
|
|
|
|
if ((bytes[0] & Helpers.MSG_ZEROCODED) != 0 && bytes[8] == 0)
|
|
{
|
|
if (bytes[9] == 1)
|
|
{
|
|
Data[9] = bytes[10];
|
|
}
|
|
else
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
pos = 10;
|
|
CreateAckList(bytes, ref packetEnd);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="i"></param>
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Data, 0, bytes, i, 10);
|
|
i += 10;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public class MediumHeader : Header
|
|
{
|
|
/// <summary></summary>
|
|
public override ushort ID
|
|
{
|
|
get { return (ushort)Data[7]; }
|
|
set { Data[7] = (byte)value; }
|
|
}
|
|
/// <summary></summary>
|
|
public override PacketFrequency Frequency { get { return PacketFrequency.Medium; } }
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public MediumHeader()
|
|
{
|
|
Data = new byte[8];
|
|
Data[6] = 0xFF;
|
|
AckList = new uint[0];
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="pos"></param>
|
|
/// <param name="packetEnd"></param>
|
|
public MediumHeader(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
FromBytes(bytes, ref pos, ref packetEnd);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
if (bytes.Length < 8) { throw new MalformedDataException(); }
|
|
Data = new byte[8];
|
|
Buffer.BlockCopy(bytes, 0, Data, 0, 8);
|
|
pos = 8;
|
|
CreateAckList(bytes, ref packetEnd);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="i"></param>
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Data, 0, bytes, i, 8);
|
|
i += 8;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public class HighHeader : Header
|
|
{
|
|
/// <summary></summary>
|
|
public override ushort ID
|
|
{
|
|
get { return (ushort)Data[6]; }
|
|
set { Data[6] = (byte)value; }
|
|
}
|
|
/// <summary></summary>
|
|
public override PacketFrequency Frequency { get { return PacketFrequency.High; } }
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
public HighHeader()
|
|
{
|
|
Data = new byte[7];
|
|
AckList = new uint[0];
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="pos"></param>
|
|
/// <param name="packetEnd"></param>
|
|
public HighHeader(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
FromBytes(bytes, ref pos, ref packetEnd);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int pos, ref int packetEnd)
|
|
{
|
|
if (bytes.Length < 7) { throw new MalformedDataException(); }
|
|
Data = new byte[7];
|
|
Buffer.BlockCopy(bytes, 0, Data, 0, 7);
|
|
pos = 7;
|
|
CreateAckList(bytes, ref packetEnd);
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="bytes"></param>
|
|
/// <param name="i"></param>
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Data, 0, bytes, i, 7);
|
|
i += 7;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A block of data in a packet. Packets are composed of one or more blocks,
|
|
/// each block containing one or more fields
|
|
/// </summary>
|
|
public abstract class PacketBlock
|
|
{
|
|
/// <summary>Current length of the data in this packet</summary>
|
|
public abstract int Length { get; }
|
|
|
|
/// <summary>
|
|
/// Create a block from a byte array
|
|
/// </summary>
|
|
/// <param name="bytes">Byte array containing the serialized block</param>
|
|
/// <param name="i">Starting position of the block in the byte array.
|
|
/// This will point to the data after the end of the block when the
|
|
/// call returns</param>
|
|
public abstract void FromBytes(byte[] bytes, ref int i);
|
|
|
|
/// <summary>
|
|
/// Serialize this block into a byte array
|
|
/// </summary>
|
|
/// <param name="bytes">Byte array to serialize this block into</param>
|
|
/// <param name="i">Starting position in the byte array to serialize to.
|
|
/// This will point to the position directly after the end of the
|
|
/// serialized block when the call returns</param>
|
|
public abstract void ToBytes(byte[] bytes, ref int i);
|
|
}
|
|
public enum PacketType
|
|
{
|
|
/// <summary>A generic value, not an actual packet type</summary>
|
|
Default,
|
|
TestMessage = 65537,
|
|
UseCircuitCode = 65539,
|
|
TelehubInfo = 65546,
|
|
EconomyDataRequest = 65560,
|
|
EconomyData = 65561,
|
|
AvatarPickerRequest = 65562,
|
|
AvatarPickerReply = 65564,
|
|
PlacesQuery = 65565,
|
|
PlacesReply = 65566,
|
|
DirFindQuery = 65567,
|
|
DirPlacesQuery = 65569,
|
|
DirPlacesReply = 65571,
|
|
DirPeopleReply = 65572,
|
|
DirEventsReply = 65573,
|
|
DirGroupsReply = 65574,
|
|
DirClassifiedQuery = 65575,
|
|
DirClassifiedReply = 65577,
|
|
AvatarClassifiedReply = 65578,
|
|
ClassifiedInfoRequest = 65579,
|
|
ClassifiedInfoReply = 65580,
|
|
ClassifiedInfoUpdate = 65581,
|
|
ClassifiedDelete = 65582,
|
|
ClassifiedGodDelete = 65583,
|
|
DirLandQuery = 65584,
|
|
DirLandReply = 65586,
|
|
DirPopularQuery = 65587,
|
|
DirPopularReply = 65589,
|
|
ParcelInfoRequest = 65590,
|
|
ParcelInfoReply = 65591,
|
|
ParcelObjectOwnersRequest = 65592,
|
|
ParcelObjectOwnersReply = 65593,
|
|
GroupNoticesListRequest = 65594,
|
|
GroupNoticesListReply = 65595,
|
|
GroupNoticeRequest = 65596,
|
|
TeleportRequest = 65598,
|
|
TeleportLocationRequest = 65599,
|
|
TeleportLocal = 65600,
|
|
TeleportLandmarkRequest = 65601,
|
|
TeleportProgress = 65602,
|
|
TeleportFinish = 65605,
|
|
StartLure = 65606,
|
|
TeleportLureRequest = 65607,
|
|
TeleportCancel = 65608,
|
|
TeleportStart = 65609,
|
|
TeleportFailed = 65610,
|
|
Undo = 65611,
|
|
Redo = 65612,
|
|
UndoLand = 65613,
|
|
AgentPause = 65614,
|
|
AgentResume = 65615,
|
|
ChatFromViewer = 65616,
|
|
AgentThrottle = 65617,
|
|
AgentFOV = 65618,
|
|
AgentHeightWidth = 65619,
|
|
AgentSetAppearance = 65620,
|
|
AgentQuitCopy = 65621,
|
|
ImageNotInDatabase = 65622,
|
|
RebakeAvatarTextures = 65623,
|
|
SetAlwaysRun = 65624,
|
|
ObjectDelete = 65625,
|
|
ObjectDuplicate = 65626,
|
|
ObjectDuplicateOnRay = 65627,
|
|
ObjectScale = 65628,
|
|
ObjectRotation = 65629,
|
|
ObjectFlagUpdate = 65630,
|
|
ObjectClickAction = 65631,
|
|
ObjectImage = 65632,
|
|
ObjectMaterial = 65633,
|
|
ObjectShape = 65634,
|
|
ObjectExtraParams = 65635,
|
|
ObjectOwner = 65636,
|
|
ObjectGroup = 65637,
|
|
ObjectBuy = 65638,
|
|
BuyObjectInventory = 65639,
|
|
DerezContainer = 65640,
|
|
ObjectPermissions = 65641,
|
|
ObjectSaleInfo = 65642,
|
|
ObjectName = 65643,
|
|
ObjectDescription = 65644,
|
|
ObjectCategory = 65645,
|
|
ObjectSelect = 65646,
|
|
ObjectDeselect = 65647,
|
|
ObjectAttach = 65648,
|
|
ObjectDetach = 65649,
|
|
ObjectDrop = 65650,
|
|
ObjectLink = 65651,
|
|
ObjectDelink = 65652,
|
|
ObjectGrab = 65653,
|
|
ObjectGrabUpdate = 65654,
|
|
ObjectDeGrab = 65655,
|
|
ObjectSpinStart = 65656,
|
|
ObjectSpinUpdate = 65657,
|
|
ObjectSpinStop = 65658,
|
|
ObjectExportSelected = 65659,
|
|
ModifyLand = 65660,
|
|
VelocityInterpolateOn = 65661,
|
|
VelocityInterpolateOff = 65662,
|
|
StateSave = 65663,
|
|
ReportAutosaveCrash = 65664,
|
|
SimWideDeletes = 65665,
|
|
TrackAgent = 65666,
|
|
ViewerStats = 65667,
|
|
ScriptAnswerYes = 65668,
|
|
UserReport = 65669,
|
|
AlertMessage = 65670,
|
|
AgentAlertMessage = 65671,
|
|
MeanCollisionAlert = 65672,
|
|
ViewerFrozenMessage = 65673,
|
|
HealthMessage = 65674,
|
|
ChatFromSimulator = 65675,
|
|
SimStats = 65676,
|
|
RequestRegionInfo = 65677,
|
|
RegionInfo = 65678,
|
|
GodUpdateRegionInfo = 65679,
|
|
NearestLandingRegionUpdated = 65682,
|
|
RegionHandshake = 65684,
|
|
RegionHandshakeReply = 65685,
|
|
SimulatorViewerTimeMessage = 65686,
|
|
EnableSimulator = 65687,
|
|
DisableSimulator = 65688,
|
|
TransferRequest = 65689,
|
|
TransferInfo = 65690,
|
|
TransferAbort = 65691,
|
|
RequestXfer = 65692,
|
|
AbortXfer = 65693,
|
|
AvatarAppearance = 65694,
|
|
SetFollowCamProperties = 65695,
|
|
ClearFollowCamProperties = 65696,
|
|
RequestPayPrice = 65697,
|
|
PayPriceReply = 65698,
|
|
KickUser = 65699,
|
|
KickUserAck = 65700,
|
|
GodKickUser = 65701,
|
|
EjectUser = 65703,
|
|
FreezeUser = 65704,
|
|
AvatarPropertiesRequest = 65705,
|
|
AvatarPropertiesReply = 65707,
|
|
AvatarInterestsReply = 65708,
|
|
AvatarGroupsReply = 65709,
|
|
AvatarPropertiesUpdate = 65710,
|
|
AvatarInterestsUpdate = 65711,
|
|
AvatarNotesReply = 65712,
|
|
AvatarNotesUpdate = 65713,
|
|
AvatarPicksReply = 65714,
|
|
EventInfoRequest = 65715,
|
|
EventInfoReply = 65716,
|
|
EventNotificationAddRequest = 65717,
|
|
EventNotificationRemoveRequest = 65718,
|
|
EventGodDelete = 65719,
|
|
PickInfoReply = 65720,
|
|
PickInfoUpdate = 65721,
|
|
PickDelete = 65722,
|
|
PickGodDelete = 65723,
|
|
ScriptQuestion = 65724,
|
|
ScriptControlChange = 65725,
|
|
ScriptDialog = 65726,
|
|
ScriptDialogReply = 65727,
|
|
ForceScriptControlRelease = 65728,
|
|
RevokePermissions = 65729,
|
|
LoadURL = 65730,
|
|
ScriptTeleportRequest = 65731,
|
|
ParcelOverlay = 65732,
|
|
ParcelPropertiesRequestByID = 65733,
|
|
ParcelPropertiesUpdate = 65734,
|
|
ParcelReturnObjects = 65735,
|
|
ParcelSetOtherCleanTime = 65736,
|
|
ParcelDisableObjects = 65737,
|
|
ParcelSelectObjects = 65738,
|
|
EstateCovenantRequest = 65739,
|
|
EstateCovenantReply = 65740,
|
|
ForceObjectSelect = 65741,
|
|
ParcelBuyPass = 65742,
|
|
ParcelDeedToGroup = 65743,
|
|
ParcelReclaim = 65744,
|
|
ParcelClaim = 65745,
|
|
ParcelJoin = 65746,
|
|
ParcelDivide = 65747,
|
|
ParcelRelease = 65748,
|
|
ParcelBuy = 65749,
|
|
ParcelGodForceOwner = 65750,
|
|
ParcelAccessListRequest = 65751,
|
|
ParcelAccessListReply = 65752,
|
|
ParcelAccessListUpdate = 65753,
|
|
ParcelDwellRequest = 65754,
|
|
ParcelDwellReply = 65755,
|
|
ParcelGodMarkAsContent = 65763,
|
|
ViewerStartAuction = 65764,
|
|
UUIDNameRequest = 65771,
|
|
UUIDNameReply = 65772,
|
|
UUIDGroupNameRequest = 65773,
|
|
UUIDGroupNameReply = 65774,
|
|
ChildAgentDying = 65776,
|
|
ChildAgentUnknown = 65777,
|
|
GetScriptRunning = 65779,
|
|
ScriptRunningReply = 65780,
|
|
SetScriptRunning = 65781,
|
|
ScriptReset = 65782,
|
|
ScriptSensorRequest = 65783,
|
|
ScriptSensorReply = 65784,
|
|
CompleteAgentMovement = 65785,
|
|
AgentMovementComplete = 65786,
|
|
LogoutRequest = 65788,
|
|
LogoutReply = 65789,
|
|
ImprovedInstantMessage = 65790,
|
|
RetrieveInstantMessages = 65791,
|
|
FindAgent = 65792,
|
|
RequestGodlikePowers = 65793,
|
|
GrantGodlikePowers = 65794,
|
|
GodlikeMessage = 65795,
|
|
EstateOwnerMessage = 65796,
|
|
GenericMessage = 65797,
|
|
MuteListRequest = 65798,
|
|
UpdateMuteListEntry = 65799,
|
|
RemoveMuteListEntry = 65800,
|
|
CopyInventoryFromNotecard = 65801,
|
|
UpdateInventoryItem = 65802,
|
|
UpdateCreateInventoryItem = 65803,
|
|
MoveInventoryItem = 65804,
|
|
CopyInventoryItem = 65805,
|
|
RemoveInventoryItem = 65806,
|
|
ChangeInventoryItemFlags = 65807,
|
|
SaveAssetIntoInventory = 65808,
|
|
CreateInventoryFolder = 65809,
|
|
UpdateInventoryFolder = 65810,
|
|
MoveInventoryFolder = 65811,
|
|
RemoveInventoryFolder = 65812,
|
|
FetchInventoryDescendents = 65813,
|
|
InventoryDescendents = 65814,
|
|
FetchInventory = 65815,
|
|
FetchInventoryReply = 65816,
|
|
BulkUpdateInventory = 65817,
|
|
RequestInventoryAsset = 65818,
|
|
InventoryAssetResponse = 65819,
|
|
RemoveInventoryObjects = 65820,
|
|
PurgeInventoryDescendents = 65821,
|
|
UpdateTaskInventory = 65822,
|
|
RemoveTaskInventory = 65823,
|
|
MoveTaskInventory = 65824,
|
|
RequestTaskInventory = 65825,
|
|
ReplyTaskInventory = 65826,
|
|
DeRezObject = 65827,
|
|
DeRezAck = 65828,
|
|
RezObject = 65829,
|
|
RezObjectFromNotecard = 65830,
|
|
AcceptFriendship = 65833,
|
|
DeclineFriendship = 65834,
|
|
FormFriendship = 65835,
|
|
TerminateFriendship = 65836,
|
|
OfferCallingCard = 65837,
|
|
AcceptCallingCard = 65838,
|
|
DeclineCallingCard = 65839,
|
|
RezScript = 65840,
|
|
CreateInventoryItem = 65841,
|
|
CreateLandmarkForEvent = 65842,
|
|
RegionHandleRequest = 65845,
|
|
RegionIDAndHandleReply = 65846,
|
|
MoneyTransferRequest = 65847,
|
|
MoneyBalanceRequest = 65849,
|
|
MoneyBalanceReply = 65850,
|
|
RoutedMoneyBalanceReply = 65851,
|
|
ActivateGestures = 65852,
|
|
DeactivateGestures = 65853,
|
|
MuteListUpdate = 65854,
|
|
UseCachedMuteList = 65855,
|
|
GrantUserRights = 65856,
|
|
ChangeUserRights = 65857,
|
|
OnlineNotification = 65858,
|
|
OfflineNotification = 65859,
|
|
SetStartLocationRequest = 65860,
|
|
AssetUploadRequest = 65869,
|
|
AssetUploadComplete = 65870,
|
|
CreateGroupRequest = 65875,
|
|
CreateGroupReply = 65876,
|
|
UpdateGroupInfo = 65877,
|
|
GroupRoleChanges = 65878,
|
|
JoinGroupRequest = 65879,
|
|
JoinGroupReply = 65880,
|
|
EjectGroupMemberRequest = 65881,
|
|
EjectGroupMemberReply = 65882,
|
|
LeaveGroupRequest = 65883,
|
|
LeaveGroupReply = 65884,
|
|
InviteGroupRequest = 65885,
|
|
GroupProfileRequest = 65887,
|
|
GroupProfileReply = 65888,
|
|
GroupAccountSummaryRequest = 65889,
|
|
GroupAccountSummaryReply = 65890,
|
|
GroupAccountDetailsRequest = 65891,
|
|
GroupAccountDetailsReply = 65892,
|
|
GroupAccountTransactionsRequest = 65893,
|
|
GroupAccountTransactionsReply = 65894,
|
|
GroupActiveProposalsRequest = 65895,
|
|
GroupActiveProposalItemReply = 65896,
|
|
GroupVoteHistoryRequest = 65897,
|
|
GroupVoteHistoryItemReply = 65898,
|
|
StartGroupProposal = 65899,
|
|
GroupProposalBallot = 65900,
|
|
GroupMembersRequest = 65902,
|
|
GroupMembersReply = 65903,
|
|
ActivateGroup = 65904,
|
|
SetGroupContribution = 65905,
|
|
SetGroupAcceptNotices = 65906,
|
|
GroupRoleDataRequest = 65907,
|
|
GroupRoleDataReply = 65908,
|
|
GroupRoleMembersRequest = 65909,
|
|
GroupRoleMembersReply = 65910,
|
|
GroupTitlesRequest = 65911,
|
|
GroupTitlesReply = 65912,
|
|
GroupTitleUpdate = 65913,
|
|
GroupRoleUpdate = 65914,
|
|
LiveHelpGroupRequest = 65915,
|
|
LiveHelpGroupReply = 65916,
|
|
AgentWearablesRequest = 65917,
|
|
AgentWearablesUpdate = 65918,
|
|
AgentIsNowWearing = 65919,
|
|
AgentCachedTexture = 65920,
|
|
AgentCachedTextureResponse = 65921,
|
|
AgentDataUpdateRequest = 65922,
|
|
AgentDataUpdate = 65923,
|
|
GroupDataUpdate = 65924,
|
|
AgentGroupDataUpdate = 65925,
|
|
AgentDropGroup = 65926,
|
|
CreateTrustedCircuit = 65928,
|
|
DenyTrustedCircuit = 65929,
|
|
RequestTrustedCircuit = 65930,
|
|
RezSingleAttachmentFromInv = 65931,
|
|
RezMultipleAttachmentsFromInv = 65932,
|
|
DetachAttachmentIntoInv = 65933,
|
|
CreateNewOutfitAttachments = 65934,
|
|
UserInfoRequest = 65935,
|
|
UserInfoReply = 65936,
|
|
UpdateUserInfo = 65937,
|
|
InitiateDownload = 65939,
|
|
SystemMessage = 65940,
|
|
MapLayerRequest = 65941,
|
|
MapLayerReply = 65942,
|
|
MapBlockRequest = 65943,
|
|
MapNameRequest = 65944,
|
|
MapBlockReply = 65945,
|
|
MapItemRequest = 65946,
|
|
MapItemReply = 65947,
|
|
SendPostcard = 65948,
|
|
ParcelMediaCommandMessage = 65955,
|
|
ParcelMediaUpdate = 65956,
|
|
LandStatRequest = 65957,
|
|
LandStatReply = 65958,
|
|
Error = 65959,
|
|
ObjectIncludeInSearch = 65960,
|
|
PacketAck = 131067,
|
|
OpenCircuit = 131068,
|
|
CloseCircuit = 131069,
|
|
ObjectAdd = 131073,
|
|
MultipleObjectUpdate = 131074,
|
|
RequestMultipleObjects = 131075,
|
|
ObjectPosition = 131076,
|
|
RequestObjectPropertiesFamily = 131077,
|
|
CoarseLocationUpdate = 131078,
|
|
CrossedRegion = 131079,
|
|
ConfirmEnableSimulator = 131080,
|
|
ObjectProperties = 131081,
|
|
ObjectPropertiesFamily = 131082,
|
|
ParcelPropertiesRequest = 131083,
|
|
AttachedSound = 131085,
|
|
AttachedSoundGainChange = 131086,
|
|
PreloadSound = 131087,
|
|
ViewerEffect = 131089,
|
|
StartPingCheck = 196609,
|
|
CompletePingCheck = 196610,
|
|
AgentUpdate = 196612,
|
|
AgentAnimation = 196613,
|
|
AgentRequestSit = 196614,
|
|
AgentSit = 196615,
|
|
RequestImage = 196616,
|
|
ImageData = 196617,
|
|
ImagePacket = 196618,
|
|
LayerData = 196619,
|
|
ObjectUpdate = 196620,
|
|
ObjectUpdateCompressed = 196621,
|
|
ObjectUpdateCached = 196622,
|
|
ImprovedTerseObjectUpdate = 196623,
|
|
KillObject = 196624,
|
|
TransferPacket = 196625,
|
|
SendXferPacket = 196626,
|
|
ConfirmXferPacket = 196627,
|
|
AvatarAnimation = 196628,
|
|
AvatarSitResponse = 196629,
|
|
CameraConstraint = 196630,
|
|
ParcelProperties = 196631,
|
|
ChildAgentUpdate = 196633,
|
|
ChildAgentAlive = 196634,
|
|
ChildAgentPositionUpdate = 196635,
|
|
SoundTrigger = 196637,
|
|
}
|
|
|
|
public abstract partial class Packet
|
|
{
|
|
public abstract Header Header { get; set; }
|
|
public abstract PacketType Type { get; }
|
|
public abstract void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer);
|
|
public abstract void FromBytes(Header header, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer);
|
|
public abstract byte[] ToBytes();
|
|
public static PacketType GetType(ushort id, PacketFrequency frequency)
|
|
{
|
|
switch (frequency)
|
|
{
|
|
case PacketFrequency.Low:
|
|
switch (id)
|
|
{
|
|
case 1: return PacketType.TestMessage;
|
|
case 3: return PacketType.UseCircuitCode;
|
|
case 10: return PacketType.TelehubInfo;
|
|
case 24: return PacketType.EconomyDataRequest;
|
|
case 25: return PacketType.EconomyData;
|
|
case 26: return PacketType.AvatarPickerRequest;
|
|
case 28: return PacketType.AvatarPickerReply;
|
|
case 29: return PacketType.PlacesQuery;
|
|
case 30: return PacketType.PlacesReply;
|
|
case 31: return PacketType.DirFindQuery;
|
|
case 33: return PacketType.DirPlacesQuery;
|
|
case 35: return PacketType.DirPlacesReply;
|
|
case 36: return PacketType.DirPeopleReply;
|
|
case 37: return PacketType.DirEventsReply;
|
|
case 38: return PacketType.DirGroupsReply;
|
|
case 39: return PacketType.DirClassifiedQuery;
|
|
case 41: return PacketType.DirClassifiedReply;
|
|
case 42: return PacketType.AvatarClassifiedReply;
|
|
case 43: return PacketType.ClassifiedInfoRequest;
|
|
case 44: return PacketType.ClassifiedInfoReply;
|
|
case 45: return PacketType.ClassifiedInfoUpdate;
|
|
case 46: return PacketType.ClassifiedDelete;
|
|
case 47: return PacketType.ClassifiedGodDelete;
|
|
case 48: return PacketType.DirLandQuery;
|
|
case 50: return PacketType.DirLandReply;
|
|
case 51: return PacketType.DirPopularQuery;
|
|
case 53: return PacketType.DirPopularReply;
|
|
case 54: return PacketType.ParcelInfoRequest;
|
|
case 55: return PacketType.ParcelInfoReply;
|
|
case 56: return PacketType.ParcelObjectOwnersRequest;
|
|
case 57: return PacketType.ParcelObjectOwnersReply;
|
|
case 58: return PacketType.GroupNoticesListRequest;
|
|
case 59: return PacketType.GroupNoticesListReply;
|
|
case 60: return PacketType.GroupNoticeRequest;
|
|
case 62: return PacketType.TeleportRequest;
|
|
case 63: return PacketType.TeleportLocationRequest;
|
|
case 64: return PacketType.TeleportLocal;
|
|
case 65: return PacketType.TeleportLandmarkRequest;
|
|
case 66: return PacketType.TeleportProgress;
|
|
case 69: return PacketType.TeleportFinish;
|
|
case 70: return PacketType.StartLure;
|
|
case 71: return PacketType.TeleportLureRequest;
|
|
case 72: return PacketType.TeleportCancel;
|
|
case 73: return PacketType.TeleportStart;
|
|
case 74: return PacketType.TeleportFailed;
|
|
case 75: return PacketType.Undo;
|
|
case 76: return PacketType.Redo;
|
|
case 77: return PacketType.UndoLand;
|
|
case 78: return PacketType.AgentPause;
|
|
case 79: return PacketType.AgentResume;
|
|
case 80: return PacketType.ChatFromViewer;
|
|
case 81: return PacketType.AgentThrottle;
|
|
case 82: return PacketType.AgentFOV;
|
|
case 83: return PacketType.AgentHeightWidth;
|
|
case 84: return PacketType.AgentSetAppearance;
|
|
case 85: return PacketType.AgentQuitCopy;
|
|
case 86: return PacketType.ImageNotInDatabase;
|
|
case 87: return PacketType.RebakeAvatarTextures;
|
|
case 88: return PacketType.SetAlwaysRun;
|
|
case 89: return PacketType.ObjectDelete;
|
|
case 90: return PacketType.ObjectDuplicate;
|
|
case 91: return PacketType.ObjectDuplicateOnRay;
|
|
case 92: return PacketType.ObjectScale;
|
|
case 93: return PacketType.ObjectRotation;
|
|
case 94: return PacketType.ObjectFlagUpdate;
|
|
case 95: return PacketType.ObjectClickAction;
|
|
case 96: return PacketType.ObjectImage;
|
|
case 97: return PacketType.ObjectMaterial;
|
|
case 98: return PacketType.ObjectShape;
|
|
case 99: return PacketType.ObjectExtraParams;
|
|
case 100: return PacketType.ObjectOwner;
|
|
case 101: return PacketType.ObjectGroup;
|
|
case 102: return PacketType.ObjectBuy;
|
|
case 103: return PacketType.BuyObjectInventory;
|
|
case 104: return PacketType.DerezContainer;
|
|
case 105: return PacketType.ObjectPermissions;
|
|
case 106: return PacketType.ObjectSaleInfo;
|
|
case 107: return PacketType.ObjectName;
|
|
case 108: return PacketType.ObjectDescription;
|
|
case 109: return PacketType.ObjectCategory;
|
|
case 110: return PacketType.ObjectSelect;
|
|
case 111: return PacketType.ObjectDeselect;
|
|
case 112: return PacketType.ObjectAttach;
|
|
case 113: return PacketType.ObjectDetach;
|
|
case 114: return PacketType.ObjectDrop;
|
|
case 115: return PacketType.ObjectLink;
|
|
case 116: return PacketType.ObjectDelink;
|
|
case 117: return PacketType.ObjectGrab;
|
|
case 118: return PacketType.ObjectGrabUpdate;
|
|
case 119: return PacketType.ObjectDeGrab;
|
|
case 120: return PacketType.ObjectSpinStart;
|
|
case 121: return PacketType.ObjectSpinUpdate;
|
|
case 122: return PacketType.ObjectSpinStop;
|
|
case 123: return PacketType.ObjectExportSelected;
|
|
case 124: return PacketType.ModifyLand;
|
|
case 125: return PacketType.VelocityInterpolateOn;
|
|
case 126: return PacketType.VelocityInterpolateOff;
|
|
case 127: return PacketType.StateSave;
|
|
case 128: return PacketType.ReportAutosaveCrash;
|
|
case 129: return PacketType.SimWideDeletes;
|
|
case 130: return PacketType.TrackAgent;
|
|
case 131: return PacketType.ViewerStats;
|
|
case 132: return PacketType.ScriptAnswerYes;
|
|
case 133: return PacketType.UserReport;
|
|
case 134: return PacketType.AlertMessage;
|
|
case 135: return PacketType.AgentAlertMessage;
|
|
case 136: return PacketType.MeanCollisionAlert;
|
|
case 137: return PacketType.ViewerFrozenMessage;
|
|
case 138: return PacketType.HealthMessage;
|
|
case 139: return PacketType.ChatFromSimulator;
|
|
case 140: return PacketType.SimStats;
|
|
case 141: return PacketType.RequestRegionInfo;
|
|
case 142: return PacketType.RegionInfo;
|
|
case 143: return PacketType.GodUpdateRegionInfo;
|
|
case 146: return PacketType.NearestLandingRegionUpdated;
|
|
case 148: return PacketType.RegionHandshake;
|
|
case 149: return PacketType.RegionHandshakeReply;
|
|
case 150: return PacketType.SimulatorViewerTimeMessage;
|
|
case 151: return PacketType.EnableSimulator;
|
|
case 152: return PacketType.DisableSimulator;
|
|
case 153: return PacketType.TransferRequest;
|
|
case 154: return PacketType.TransferInfo;
|
|
case 155: return PacketType.TransferAbort;
|
|
case 156: return PacketType.RequestXfer;
|
|
case 157: return PacketType.AbortXfer;
|
|
case 158: return PacketType.AvatarAppearance;
|
|
case 159: return PacketType.SetFollowCamProperties;
|
|
case 160: return PacketType.ClearFollowCamProperties;
|
|
case 161: return PacketType.RequestPayPrice;
|
|
case 162: return PacketType.PayPriceReply;
|
|
case 163: return PacketType.KickUser;
|
|
case 164: return PacketType.KickUserAck;
|
|
case 165: return PacketType.GodKickUser;
|
|
case 167: return PacketType.EjectUser;
|
|
case 168: return PacketType.FreezeUser;
|
|
case 169: return PacketType.AvatarPropertiesRequest;
|
|
case 171: return PacketType.AvatarPropertiesReply;
|
|
case 172: return PacketType.AvatarInterestsReply;
|
|
case 173: return PacketType.AvatarGroupsReply;
|
|
case 174: return PacketType.AvatarPropertiesUpdate;
|
|
case 175: return PacketType.AvatarInterestsUpdate;
|
|
case 176: return PacketType.AvatarNotesReply;
|
|
case 177: return PacketType.AvatarNotesUpdate;
|
|
case 178: return PacketType.AvatarPicksReply;
|
|
case 179: return PacketType.EventInfoRequest;
|
|
case 180: return PacketType.EventInfoReply;
|
|
case 181: return PacketType.EventNotificationAddRequest;
|
|
case 182: return PacketType.EventNotificationRemoveRequest;
|
|
case 183: return PacketType.EventGodDelete;
|
|
case 184: return PacketType.PickInfoReply;
|
|
case 185: return PacketType.PickInfoUpdate;
|
|
case 186: return PacketType.PickDelete;
|
|
case 187: return PacketType.PickGodDelete;
|
|
case 188: return PacketType.ScriptQuestion;
|
|
case 189: return PacketType.ScriptControlChange;
|
|
case 190: return PacketType.ScriptDialog;
|
|
case 191: return PacketType.ScriptDialogReply;
|
|
case 192: return PacketType.ForceScriptControlRelease;
|
|
case 193: return PacketType.RevokePermissions;
|
|
case 194: return PacketType.LoadURL;
|
|
case 195: return PacketType.ScriptTeleportRequest;
|
|
case 196: return PacketType.ParcelOverlay;
|
|
case 197: return PacketType.ParcelPropertiesRequestByID;
|
|
case 198: return PacketType.ParcelPropertiesUpdate;
|
|
case 199: return PacketType.ParcelReturnObjects;
|
|
case 200: return PacketType.ParcelSetOtherCleanTime;
|
|
case 201: return PacketType.ParcelDisableObjects;
|
|
case 202: return PacketType.ParcelSelectObjects;
|
|
case 203: return PacketType.EstateCovenantRequest;
|
|
case 204: return PacketType.EstateCovenantReply;
|
|
case 205: return PacketType.ForceObjectSelect;
|
|
case 206: return PacketType.ParcelBuyPass;
|
|
case 207: return PacketType.ParcelDeedToGroup;
|
|
case 208: return PacketType.ParcelReclaim;
|
|
case 209: return PacketType.ParcelClaim;
|
|
case 210: return PacketType.ParcelJoin;
|
|
case 211: return PacketType.ParcelDivide;
|
|
case 212: return PacketType.ParcelRelease;
|
|
case 213: return PacketType.ParcelBuy;
|
|
case 214: return PacketType.ParcelGodForceOwner;
|
|
case 215: return PacketType.ParcelAccessListRequest;
|
|
case 216: return PacketType.ParcelAccessListReply;
|
|
case 217: return PacketType.ParcelAccessListUpdate;
|
|
case 218: return PacketType.ParcelDwellRequest;
|
|
case 219: return PacketType.ParcelDwellReply;
|
|
case 227: return PacketType.ParcelGodMarkAsContent;
|
|
case 228: return PacketType.ViewerStartAuction;
|
|
case 235: return PacketType.UUIDNameRequest;
|
|
case 236: return PacketType.UUIDNameReply;
|
|
case 237: return PacketType.UUIDGroupNameRequest;
|
|
case 238: return PacketType.UUIDGroupNameReply;
|
|
case 240: return PacketType.ChildAgentDying;
|
|
case 241: return PacketType.ChildAgentUnknown;
|
|
case 243: return PacketType.GetScriptRunning;
|
|
case 244: return PacketType.ScriptRunningReply;
|
|
case 245: return PacketType.SetScriptRunning;
|
|
case 246: return PacketType.ScriptReset;
|
|
case 247: return PacketType.ScriptSensorRequest;
|
|
case 248: return PacketType.ScriptSensorReply;
|
|
case 249: return PacketType.CompleteAgentMovement;
|
|
case 250: return PacketType.AgentMovementComplete;
|
|
case 252: return PacketType.LogoutRequest;
|
|
case 253: return PacketType.LogoutReply;
|
|
case 254: return PacketType.ImprovedInstantMessage;
|
|
case 255: return PacketType.RetrieveInstantMessages;
|
|
case 256: return PacketType.FindAgent;
|
|
case 257: return PacketType.RequestGodlikePowers;
|
|
case 258: return PacketType.GrantGodlikePowers;
|
|
case 259: return PacketType.GodlikeMessage;
|
|
case 260: return PacketType.EstateOwnerMessage;
|
|
case 261: return PacketType.GenericMessage;
|
|
case 262: return PacketType.MuteListRequest;
|
|
case 263: return PacketType.UpdateMuteListEntry;
|
|
case 264: return PacketType.RemoveMuteListEntry;
|
|
case 265: return PacketType.CopyInventoryFromNotecard;
|
|
case 266: return PacketType.UpdateInventoryItem;
|
|
case 267: return PacketType.UpdateCreateInventoryItem;
|
|
case 268: return PacketType.MoveInventoryItem;
|
|
case 269: return PacketType.CopyInventoryItem;
|
|
case 270: return PacketType.RemoveInventoryItem;
|
|
case 271: return PacketType.ChangeInventoryItemFlags;
|
|
case 272: return PacketType.SaveAssetIntoInventory;
|
|
case 273: return PacketType.CreateInventoryFolder;
|
|
case 274: return PacketType.UpdateInventoryFolder;
|
|
case 275: return PacketType.MoveInventoryFolder;
|
|
case 276: return PacketType.RemoveInventoryFolder;
|
|
case 277: return PacketType.FetchInventoryDescendents;
|
|
case 278: return PacketType.InventoryDescendents;
|
|
case 279: return PacketType.FetchInventory;
|
|
case 280: return PacketType.FetchInventoryReply;
|
|
case 281: return PacketType.BulkUpdateInventory;
|
|
case 282: return PacketType.RequestInventoryAsset;
|
|
case 283: return PacketType.InventoryAssetResponse;
|
|
case 284: return PacketType.RemoveInventoryObjects;
|
|
case 285: return PacketType.PurgeInventoryDescendents;
|
|
case 286: return PacketType.UpdateTaskInventory;
|
|
case 287: return PacketType.RemoveTaskInventory;
|
|
case 288: return PacketType.MoveTaskInventory;
|
|
case 289: return PacketType.RequestTaskInventory;
|
|
case 290: return PacketType.ReplyTaskInventory;
|
|
case 291: return PacketType.DeRezObject;
|
|
case 292: return PacketType.DeRezAck;
|
|
case 293: return PacketType.RezObject;
|
|
case 294: return PacketType.RezObjectFromNotecard;
|
|
case 297: return PacketType.AcceptFriendship;
|
|
case 298: return PacketType.DeclineFriendship;
|
|
case 299: return PacketType.FormFriendship;
|
|
case 300: return PacketType.TerminateFriendship;
|
|
case 301: return PacketType.OfferCallingCard;
|
|
case 302: return PacketType.AcceptCallingCard;
|
|
case 303: return PacketType.DeclineCallingCard;
|
|
case 304: return PacketType.RezScript;
|
|
case 305: return PacketType.CreateInventoryItem;
|
|
case 306: return PacketType.CreateLandmarkForEvent;
|
|
case 309: return PacketType.RegionHandleRequest;
|
|
case 310: return PacketType.RegionIDAndHandleReply;
|
|
case 311: return PacketType.MoneyTransferRequest;
|
|
case 313: return PacketType.MoneyBalanceRequest;
|
|
case 314: return PacketType.MoneyBalanceReply;
|
|
case 315: return PacketType.RoutedMoneyBalanceReply;
|
|
case 316: return PacketType.ActivateGestures;
|
|
case 317: return PacketType.DeactivateGestures;
|
|
case 318: return PacketType.MuteListUpdate;
|
|
case 319: return PacketType.UseCachedMuteList;
|
|
case 320: return PacketType.GrantUserRights;
|
|
case 321: return PacketType.ChangeUserRights;
|
|
case 322: return PacketType.OnlineNotification;
|
|
case 323: return PacketType.OfflineNotification;
|
|
case 324: return PacketType.SetStartLocationRequest;
|
|
case 333: return PacketType.AssetUploadRequest;
|
|
case 334: return PacketType.AssetUploadComplete;
|
|
case 339: return PacketType.CreateGroupRequest;
|
|
case 340: return PacketType.CreateGroupReply;
|
|
case 341: return PacketType.UpdateGroupInfo;
|
|
case 342: return PacketType.GroupRoleChanges;
|
|
case 343: return PacketType.JoinGroupRequest;
|
|
case 344: return PacketType.JoinGroupReply;
|
|
case 345: return PacketType.EjectGroupMemberRequest;
|
|
case 346: return PacketType.EjectGroupMemberReply;
|
|
case 347: return PacketType.LeaveGroupRequest;
|
|
case 348: return PacketType.LeaveGroupReply;
|
|
case 349: return PacketType.InviteGroupRequest;
|
|
case 351: return PacketType.GroupProfileRequest;
|
|
case 352: return PacketType.GroupProfileReply;
|
|
case 353: return PacketType.GroupAccountSummaryRequest;
|
|
case 354: return PacketType.GroupAccountSummaryReply;
|
|
case 355: return PacketType.GroupAccountDetailsRequest;
|
|
case 356: return PacketType.GroupAccountDetailsReply;
|
|
case 357: return PacketType.GroupAccountTransactionsRequest;
|
|
case 358: return PacketType.GroupAccountTransactionsReply;
|
|
case 359: return PacketType.GroupActiveProposalsRequest;
|
|
case 360: return PacketType.GroupActiveProposalItemReply;
|
|
case 361: return PacketType.GroupVoteHistoryRequest;
|
|
case 362: return PacketType.GroupVoteHistoryItemReply;
|
|
case 363: return PacketType.StartGroupProposal;
|
|
case 364: return PacketType.GroupProposalBallot;
|
|
case 366: return PacketType.GroupMembersRequest;
|
|
case 367: return PacketType.GroupMembersReply;
|
|
case 368: return PacketType.ActivateGroup;
|
|
case 369: return PacketType.SetGroupContribution;
|
|
case 370: return PacketType.SetGroupAcceptNotices;
|
|
case 371: return PacketType.GroupRoleDataRequest;
|
|
case 372: return PacketType.GroupRoleDataReply;
|
|
case 373: return PacketType.GroupRoleMembersRequest;
|
|
case 374: return PacketType.GroupRoleMembersReply;
|
|
case 375: return PacketType.GroupTitlesRequest;
|
|
case 376: return PacketType.GroupTitlesReply;
|
|
case 377: return PacketType.GroupTitleUpdate;
|
|
case 378: return PacketType.GroupRoleUpdate;
|
|
case 379: return PacketType.LiveHelpGroupRequest;
|
|
case 380: return PacketType.LiveHelpGroupReply;
|
|
case 381: return PacketType.AgentWearablesRequest;
|
|
case 382: return PacketType.AgentWearablesUpdate;
|
|
case 383: return PacketType.AgentIsNowWearing;
|
|
case 384: return PacketType.AgentCachedTexture;
|
|
case 385: return PacketType.AgentCachedTextureResponse;
|
|
case 386: return PacketType.AgentDataUpdateRequest;
|
|
case 387: return PacketType.AgentDataUpdate;
|
|
case 388: return PacketType.GroupDataUpdate;
|
|
case 389: return PacketType.AgentGroupDataUpdate;
|
|
case 390: return PacketType.AgentDropGroup;
|
|
case 392: return PacketType.CreateTrustedCircuit;
|
|
case 393: return PacketType.DenyTrustedCircuit;
|
|
case 394: return PacketType.RequestTrustedCircuit;
|
|
case 395: return PacketType.RezSingleAttachmentFromInv;
|
|
case 396: return PacketType.RezMultipleAttachmentsFromInv;
|
|
case 397: return PacketType.DetachAttachmentIntoInv;
|
|
case 398: return PacketType.CreateNewOutfitAttachments;
|
|
case 399: return PacketType.UserInfoRequest;
|
|
case 400: return PacketType.UserInfoReply;
|
|
case 401: return PacketType.UpdateUserInfo;
|
|
case 403: return PacketType.InitiateDownload;
|
|
case 404: return PacketType.SystemMessage;
|
|
case 405: return PacketType.MapLayerRequest;
|
|
case 406: return PacketType.MapLayerReply;
|
|
case 407: return PacketType.MapBlockRequest;
|
|
case 408: return PacketType.MapNameRequest;
|
|
case 409: return PacketType.MapBlockReply;
|
|
case 410: return PacketType.MapItemRequest;
|
|
case 411: return PacketType.MapItemReply;
|
|
case 412: return PacketType.SendPostcard;
|
|
case 419: return PacketType.ParcelMediaCommandMessage;
|
|
case 420: return PacketType.ParcelMediaUpdate;
|
|
case 421: return PacketType.LandStatRequest;
|
|
case 422: return PacketType.LandStatReply;
|
|
case 423: return PacketType.Error;
|
|
case 424: return PacketType.ObjectIncludeInSearch;
|
|
case 65531: return PacketType.PacketAck;
|
|
case 65532: return PacketType.OpenCircuit;
|
|
case 65533: return PacketType.CloseCircuit;
|
|
}
|
|
break;
|
|
case PacketFrequency.Medium:
|
|
switch (id)
|
|
{
|
|
case 1: return PacketType.ObjectAdd;
|
|
case 2: return PacketType.MultipleObjectUpdate;
|
|
case 3: return PacketType.RequestMultipleObjects;
|
|
case 4: return PacketType.ObjectPosition;
|
|
case 5: return PacketType.RequestObjectPropertiesFamily;
|
|
case 6: return PacketType.CoarseLocationUpdate;
|
|
case 7: return PacketType.CrossedRegion;
|
|
case 8: return PacketType.ConfirmEnableSimulator;
|
|
case 9: return PacketType.ObjectProperties;
|
|
case 10: return PacketType.ObjectPropertiesFamily;
|
|
case 11: return PacketType.ParcelPropertiesRequest;
|
|
case 13: return PacketType.AttachedSound;
|
|
case 14: return PacketType.AttachedSoundGainChange;
|
|
case 15: return PacketType.PreloadSound;
|
|
case 17: return PacketType.ViewerEffect;
|
|
}
|
|
break;
|
|
case PacketFrequency.High:
|
|
switch (id)
|
|
{
|
|
case 1: return PacketType.StartPingCheck;
|
|
case 2: return PacketType.CompletePingCheck;
|
|
case 4: return PacketType.AgentUpdate;
|
|
case 5: return PacketType.AgentAnimation;
|
|
case 6: return PacketType.AgentRequestSit;
|
|
case 7: return PacketType.AgentSit;
|
|
case 8: return PacketType.RequestImage;
|
|
case 9: return PacketType.ImageData;
|
|
case 10: return PacketType.ImagePacket;
|
|
case 11: return PacketType.LayerData;
|
|
case 12: return PacketType.ObjectUpdate;
|
|
case 13: return PacketType.ObjectUpdateCompressed;
|
|
case 14: return PacketType.ObjectUpdateCached;
|
|
case 15: return PacketType.ImprovedTerseObjectUpdate;
|
|
case 16: return PacketType.KillObject;
|
|
case 17: return PacketType.TransferPacket;
|
|
case 18: return PacketType.SendXferPacket;
|
|
case 19: return PacketType.ConfirmXferPacket;
|
|
case 20: return PacketType.AvatarAnimation;
|
|
case 21: return PacketType.AvatarSitResponse;
|
|
case 22: return PacketType.CameraConstraint;
|
|
case 23: return PacketType.ParcelProperties;
|
|
case 25: return PacketType.ChildAgentUpdate;
|
|
case 26: return PacketType.ChildAgentAlive;
|
|
case 27: return PacketType.ChildAgentPositionUpdate;
|
|
case 29: return PacketType.SoundTrigger;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return PacketType.Default;
|
|
}
|
|
|
|
public static Packet BuildPacket(PacketType type)
|
|
{
|
|
if(type == PacketType.StartPingCheck) return new StartPingCheckPacket();
|
|
if(type == PacketType.CompletePingCheck) return new CompletePingCheckPacket();
|
|
if(type == PacketType.AgentUpdate) return new AgentUpdatePacket();
|
|
if(type == PacketType.AgentAnimation) return new AgentAnimationPacket();
|
|
if(type == PacketType.AgentRequestSit) return new AgentRequestSitPacket();
|
|
if(type == PacketType.AgentSit) return new AgentSitPacket();
|
|
if(type == PacketType.RequestImage) return new RequestImagePacket();
|
|
if(type == PacketType.ImageData) return new ImageDataPacket();
|
|
if(type == PacketType.ImagePacket) return new ImagePacketPacket();
|
|
if(type == PacketType.LayerData) return new LayerDataPacket();
|
|
if(type == PacketType.ObjectUpdate) return new ObjectUpdatePacket();
|
|
if(type == PacketType.ObjectUpdateCompressed) return new ObjectUpdateCompressedPacket();
|
|
if(type == PacketType.ObjectUpdateCached) return new ObjectUpdateCachedPacket();
|
|
if(type == PacketType.ImprovedTerseObjectUpdate) return new ImprovedTerseObjectUpdatePacket();
|
|
if(type == PacketType.KillObject) return new KillObjectPacket();
|
|
if(type == PacketType.TransferPacket) return new TransferPacketPacket();
|
|
if(type == PacketType.SendXferPacket) return new SendXferPacketPacket();
|
|
if(type == PacketType.ConfirmXferPacket) return new ConfirmXferPacketPacket();
|
|
if(type == PacketType.AvatarAnimation) return new AvatarAnimationPacket();
|
|
if(type == PacketType.AvatarSitResponse) return new AvatarSitResponsePacket();
|
|
if(type == PacketType.CameraConstraint) return new CameraConstraintPacket();
|
|
if(type == PacketType.ParcelProperties) return new ParcelPropertiesPacket();
|
|
if(type == PacketType.ChildAgentUpdate) return new ChildAgentUpdatePacket();
|
|
if(type == PacketType.ChildAgentAlive) return new ChildAgentAlivePacket();
|
|
if(type == PacketType.ChildAgentPositionUpdate) return new ChildAgentPositionUpdatePacket();
|
|
if(type == PacketType.SoundTrigger) return new SoundTriggerPacket();
|
|
if(type == PacketType.ObjectAdd) return new ObjectAddPacket();
|
|
if(type == PacketType.MultipleObjectUpdate) return new MultipleObjectUpdatePacket();
|
|
if(type == PacketType.RequestMultipleObjects) return new RequestMultipleObjectsPacket();
|
|
if(type == PacketType.ObjectPosition) return new ObjectPositionPacket();
|
|
if(type == PacketType.RequestObjectPropertiesFamily) return new RequestObjectPropertiesFamilyPacket();
|
|
if(type == PacketType.CoarseLocationUpdate) return new CoarseLocationUpdatePacket();
|
|
if(type == PacketType.CrossedRegion) return new CrossedRegionPacket();
|
|
if(type == PacketType.ConfirmEnableSimulator) return new ConfirmEnableSimulatorPacket();
|
|
if(type == PacketType.ObjectProperties) return new ObjectPropertiesPacket();
|
|
if(type == PacketType.ObjectPropertiesFamily) return new ObjectPropertiesFamilyPacket();
|
|
if(type == PacketType.ParcelPropertiesRequest) return new ParcelPropertiesRequestPacket();
|
|
if(type == PacketType.AttachedSound) return new AttachedSoundPacket();
|
|
if(type == PacketType.AttachedSoundGainChange) return new AttachedSoundGainChangePacket();
|
|
if(type == PacketType.PreloadSound) return new PreloadSoundPacket();
|
|
if(type == PacketType.ViewerEffect) return new ViewerEffectPacket();
|
|
if(type == PacketType.TestMessage) return new TestMessagePacket();
|
|
if(type == PacketType.UseCircuitCode) return new UseCircuitCodePacket();
|
|
if(type == PacketType.TelehubInfo) return new TelehubInfoPacket();
|
|
if(type == PacketType.EconomyDataRequest) return new EconomyDataRequestPacket();
|
|
if(type == PacketType.EconomyData) return new EconomyDataPacket();
|
|
if(type == PacketType.AvatarPickerRequest) return new AvatarPickerRequestPacket();
|
|
if(type == PacketType.AvatarPickerReply) return new AvatarPickerReplyPacket();
|
|
if(type == PacketType.PlacesQuery) return new PlacesQueryPacket();
|
|
if(type == PacketType.PlacesReply) return new PlacesReplyPacket();
|
|
if(type == PacketType.DirFindQuery) return new DirFindQueryPacket();
|
|
if(type == PacketType.DirPlacesQuery) return new DirPlacesQueryPacket();
|
|
if(type == PacketType.DirPlacesReply) return new DirPlacesReplyPacket();
|
|
if(type == PacketType.DirPeopleReply) return new DirPeopleReplyPacket();
|
|
if(type == PacketType.DirEventsReply) return new DirEventsReplyPacket();
|
|
if(type == PacketType.DirGroupsReply) return new DirGroupsReplyPacket();
|
|
if(type == PacketType.DirClassifiedQuery) return new DirClassifiedQueryPacket();
|
|
if(type == PacketType.DirClassifiedReply) return new DirClassifiedReplyPacket();
|
|
if(type == PacketType.AvatarClassifiedReply) return new AvatarClassifiedReplyPacket();
|
|
if(type == PacketType.ClassifiedInfoRequest) return new ClassifiedInfoRequestPacket();
|
|
if(type == PacketType.ClassifiedInfoReply) return new ClassifiedInfoReplyPacket();
|
|
if(type == PacketType.ClassifiedInfoUpdate) return new ClassifiedInfoUpdatePacket();
|
|
if(type == PacketType.ClassifiedDelete) return new ClassifiedDeletePacket();
|
|
if(type == PacketType.ClassifiedGodDelete) return new ClassifiedGodDeletePacket();
|
|
if(type == PacketType.DirLandQuery) return new DirLandQueryPacket();
|
|
if(type == PacketType.DirLandReply) return new DirLandReplyPacket();
|
|
if(type == PacketType.DirPopularQuery) return new DirPopularQueryPacket();
|
|
if(type == PacketType.DirPopularReply) return new DirPopularReplyPacket();
|
|
if(type == PacketType.ParcelInfoRequest) return new ParcelInfoRequestPacket();
|
|
if(type == PacketType.ParcelInfoReply) return new ParcelInfoReplyPacket();
|
|
if(type == PacketType.ParcelObjectOwnersRequest) return new ParcelObjectOwnersRequestPacket();
|
|
if(type == PacketType.ParcelObjectOwnersReply) return new ParcelObjectOwnersReplyPacket();
|
|
if(type == PacketType.GroupNoticesListRequest) return new GroupNoticesListRequestPacket();
|
|
if(type == PacketType.GroupNoticesListReply) return new GroupNoticesListReplyPacket();
|
|
if(type == PacketType.GroupNoticeRequest) return new GroupNoticeRequestPacket();
|
|
if(type == PacketType.TeleportRequest) return new TeleportRequestPacket();
|
|
if(type == PacketType.TeleportLocationRequest) return new TeleportLocationRequestPacket();
|
|
if(type == PacketType.TeleportLocal) return new TeleportLocalPacket();
|
|
if(type == PacketType.TeleportLandmarkRequest) return new TeleportLandmarkRequestPacket();
|
|
if(type == PacketType.TeleportProgress) return new TeleportProgressPacket();
|
|
if(type == PacketType.TeleportFinish) return new TeleportFinishPacket();
|
|
if(type == PacketType.StartLure) return new StartLurePacket();
|
|
if(type == PacketType.TeleportLureRequest) return new TeleportLureRequestPacket();
|
|
if(type == PacketType.TeleportCancel) return new TeleportCancelPacket();
|
|
if(type == PacketType.TeleportStart) return new TeleportStartPacket();
|
|
if(type == PacketType.TeleportFailed) return new TeleportFailedPacket();
|
|
if(type == PacketType.Undo) return new UndoPacket();
|
|
if(type == PacketType.Redo) return new RedoPacket();
|
|
if(type == PacketType.UndoLand) return new UndoLandPacket();
|
|
if(type == PacketType.AgentPause) return new AgentPausePacket();
|
|
if(type == PacketType.AgentResume) return new AgentResumePacket();
|
|
if(type == PacketType.ChatFromViewer) return new ChatFromViewerPacket();
|
|
if(type == PacketType.AgentThrottle) return new AgentThrottlePacket();
|
|
if(type == PacketType.AgentFOV) return new AgentFOVPacket();
|
|
if(type == PacketType.AgentHeightWidth) return new AgentHeightWidthPacket();
|
|
if(type == PacketType.AgentSetAppearance) return new AgentSetAppearancePacket();
|
|
if(type == PacketType.AgentQuitCopy) return new AgentQuitCopyPacket();
|
|
if(type == PacketType.ImageNotInDatabase) return new ImageNotInDatabasePacket();
|
|
if(type == PacketType.RebakeAvatarTextures) return new RebakeAvatarTexturesPacket();
|
|
if(type == PacketType.SetAlwaysRun) return new SetAlwaysRunPacket();
|
|
if(type == PacketType.ObjectDelete) return new ObjectDeletePacket();
|
|
if(type == PacketType.ObjectDuplicate) return new ObjectDuplicatePacket();
|
|
if(type == PacketType.ObjectDuplicateOnRay) return new ObjectDuplicateOnRayPacket();
|
|
if(type == PacketType.ObjectScale) return new ObjectScalePacket();
|
|
if(type == PacketType.ObjectRotation) return new ObjectRotationPacket();
|
|
if(type == PacketType.ObjectFlagUpdate) return new ObjectFlagUpdatePacket();
|
|
if(type == PacketType.ObjectClickAction) return new ObjectClickActionPacket();
|
|
if(type == PacketType.ObjectImage) return new ObjectImagePacket();
|
|
if(type == PacketType.ObjectMaterial) return new ObjectMaterialPacket();
|
|
if(type == PacketType.ObjectShape) return new ObjectShapePacket();
|
|
if(type == PacketType.ObjectExtraParams) return new ObjectExtraParamsPacket();
|
|
if(type == PacketType.ObjectOwner) return new ObjectOwnerPacket();
|
|
if(type == PacketType.ObjectGroup) return new ObjectGroupPacket();
|
|
if(type == PacketType.ObjectBuy) return new ObjectBuyPacket();
|
|
if(type == PacketType.BuyObjectInventory) return new BuyObjectInventoryPacket();
|
|
if(type == PacketType.DerezContainer) return new DerezContainerPacket();
|
|
if(type == PacketType.ObjectPermissions) return new ObjectPermissionsPacket();
|
|
if(type == PacketType.ObjectSaleInfo) return new ObjectSaleInfoPacket();
|
|
if(type == PacketType.ObjectName) return new ObjectNamePacket();
|
|
if(type == PacketType.ObjectDescription) return new ObjectDescriptionPacket();
|
|
if(type == PacketType.ObjectCategory) return new ObjectCategoryPacket();
|
|
if(type == PacketType.ObjectSelect) return new ObjectSelectPacket();
|
|
if(type == PacketType.ObjectDeselect) return new ObjectDeselectPacket();
|
|
if(type == PacketType.ObjectAttach) return new ObjectAttachPacket();
|
|
if(type == PacketType.ObjectDetach) return new ObjectDetachPacket();
|
|
if(type == PacketType.ObjectDrop) return new ObjectDropPacket();
|
|
if(type == PacketType.ObjectLink) return new ObjectLinkPacket();
|
|
if(type == PacketType.ObjectDelink) return new ObjectDelinkPacket();
|
|
if(type == PacketType.ObjectGrab) return new ObjectGrabPacket();
|
|
if(type == PacketType.ObjectGrabUpdate) return new ObjectGrabUpdatePacket();
|
|
if(type == PacketType.ObjectDeGrab) return new ObjectDeGrabPacket();
|
|
if(type == PacketType.ObjectSpinStart) return new ObjectSpinStartPacket();
|
|
if(type == PacketType.ObjectSpinUpdate) return new ObjectSpinUpdatePacket();
|
|
if(type == PacketType.ObjectSpinStop) return new ObjectSpinStopPacket();
|
|
if(type == PacketType.ObjectExportSelected) return new ObjectExportSelectedPacket();
|
|
if(type == PacketType.ModifyLand) return new ModifyLandPacket();
|
|
if(type == PacketType.VelocityInterpolateOn) return new VelocityInterpolateOnPacket();
|
|
if(type == PacketType.VelocityInterpolateOff) return new VelocityInterpolateOffPacket();
|
|
if(type == PacketType.StateSave) return new StateSavePacket();
|
|
if(type == PacketType.ReportAutosaveCrash) return new ReportAutosaveCrashPacket();
|
|
if(type == PacketType.SimWideDeletes) return new SimWideDeletesPacket();
|
|
if(type == PacketType.TrackAgent) return new TrackAgentPacket();
|
|
if(type == PacketType.ViewerStats) return new ViewerStatsPacket();
|
|
if(type == PacketType.ScriptAnswerYes) return new ScriptAnswerYesPacket();
|
|
if(type == PacketType.UserReport) return new UserReportPacket();
|
|
if(type == PacketType.AlertMessage) return new AlertMessagePacket();
|
|
if(type == PacketType.AgentAlertMessage) return new AgentAlertMessagePacket();
|
|
if(type == PacketType.MeanCollisionAlert) return new MeanCollisionAlertPacket();
|
|
if(type == PacketType.ViewerFrozenMessage) return new ViewerFrozenMessagePacket();
|
|
if(type == PacketType.HealthMessage) return new HealthMessagePacket();
|
|
if(type == PacketType.ChatFromSimulator) return new ChatFromSimulatorPacket();
|
|
if(type == PacketType.SimStats) return new SimStatsPacket();
|
|
if(type == PacketType.RequestRegionInfo) return new RequestRegionInfoPacket();
|
|
if(type == PacketType.RegionInfo) return new RegionInfoPacket();
|
|
if(type == PacketType.GodUpdateRegionInfo) return new GodUpdateRegionInfoPacket();
|
|
if(type == PacketType.NearestLandingRegionUpdated) return new NearestLandingRegionUpdatedPacket();
|
|
if(type == PacketType.RegionHandshake) return new RegionHandshakePacket();
|
|
if(type == PacketType.RegionHandshakeReply) return new RegionHandshakeReplyPacket();
|
|
if(type == PacketType.SimulatorViewerTimeMessage) return new SimulatorViewerTimeMessagePacket();
|
|
if(type == PacketType.EnableSimulator) return new EnableSimulatorPacket();
|
|
if(type == PacketType.DisableSimulator) return new DisableSimulatorPacket();
|
|
if(type == PacketType.TransferRequest) return new TransferRequestPacket();
|
|
if(type == PacketType.TransferInfo) return new TransferInfoPacket();
|
|
if(type == PacketType.TransferAbort) return new TransferAbortPacket();
|
|
if(type == PacketType.RequestXfer) return new RequestXferPacket();
|
|
if(type == PacketType.AbortXfer) return new AbortXferPacket();
|
|
if(type == PacketType.AvatarAppearance) return new AvatarAppearancePacket();
|
|
if(type == PacketType.SetFollowCamProperties) return new SetFollowCamPropertiesPacket();
|
|
if(type == PacketType.ClearFollowCamProperties) return new ClearFollowCamPropertiesPacket();
|
|
if(type == PacketType.RequestPayPrice) return new RequestPayPricePacket();
|
|
if(type == PacketType.PayPriceReply) return new PayPriceReplyPacket();
|
|
if(type == PacketType.KickUser) return new KickUserPacket();
|
|
if(type == PacketType.KickUserAck) return new KickUserAckPacket();
|
|
if(type == PacketType.GodKickUser) return new GodKickUserPacket();
|
|
if(type == PacketType.EjectUser) return new EjectUserPacket();
|
|
if(type == PacketType.FreezeUser) return new FreezeUserPacket();
|
|
if(type == PacketType.AvatarPropertiesRequest) return new AvatarPropertiesRequestPacket();
|
|
if(type == PacketType.AvatarPropertiesReply) return new AvatarPropertiesReplyPacket();
|
|
if(type == PacketType.AvatarInterestsReply) return new AvatarInterestsReplyPacket();
|
|
if(type == PacketType.AvatarGroupsReply) return new AvatarGroupsReplyPacket();
|
|
if(type == PacketType.AvatarPropertiesUpdate) return new AvatarPropertiesUpdatePacket();
|
|
if(type == PacketType.AvatarInterestsUpdate) return new AvatarInterestsUpdatePacket();
|
|
if(type == PacketType.AvatarNotesReply) return new AvatarNotesReplyPacket();
|
|
if(type == PacketType.AvatarNotesUpdate) return new AvatarNotesUpdatePacket();
|
|
if(type == PacketType.AvatarPicksReply) return new AvatarPicksReplyPacket();
|
|
if(type == PacketType.EventInfoRequest) return new EventInfoRequestPacket();
|
|
if(type == PacketType.EventInfoReply) return new EventInfoReplyPacket();
|
|
if(type == PacketType.EventNotificationAddRequest) return new EventNotificationAddRequestPacket();
|
|
if(type == PacketType.EventNotificationRemoveRequest) return new EventNotificationRemoveRequestPacket();
|
|
if(type == PacketType.EventGodDelete) return new EventGodDeletePacket();
|
|
if(type == PacketType.PickInfoReply) return new PickInfoReplyPacket();
|
|
if(type == PacketType.PickInfoUpdate) return new PickInfoUpdatePacket();
|
|
if(type == PacketType.PickDelete) return new PickDeletePacket();
|
|
if(type == PacketType.PickGodDelete) return new PickGodDeletePacket();
|
|
if(type == PacketType.ScriptQuestion) return new ScriptQuestionPacket();
|
|
if(type == PacketType.ScriptControlChange) return new ScriptControlChangePacket();
|
|
if(type == PacketType.ScriptDialog) return new ScriptDialogPacket();
|
|
if(type == PacketType.ScriptDialogReply) return new ScriptDialogReplyPacket();
|
|
if(type == PacketType.ForceScriptControlRelease) return new ForceScriptControlReleasePacket();
|
|
if(type == PacketType.RevokePermissions) return new RevokePermissionsPacket();
|
|
if(type == PacketType.LoadURL) return new LoadURLPacket();
|
|
if(type == PacketType.ScriptTeleportRequest) return new ScriptTeleportRequestPacket();
|
|
if(type == PacketType.ParcelOverlay) return new ParcelOverlayPacket();
|
|
if(type == PacketType.ParcelPropertiesRequestByID) return new ParcelPropertiesRequestByIDPacket();
|
|
if(type == PacketType.ParcelPropertiesUpdate) return new ParcelPropertiesUpdatePacket();
|
|
if(type == PacketType.ParcelReturnObjects) return new ParcelReturnObjectsPacket();
|
|
if(type == PacketType.ParcelSetOtherCleanTime) return new ParcelSetOtherCleanTimePacket();
|
|
if(type == PacketType.ParcelDisableObjects) return new ParcelDisableObjectsPacket();
|
|
if(type == PacketType.ParcelSelectObjects) return new ParcelSelectObjectsPacket();
|
|
if(type == PacketType.EstateCovenantRequest) return new EstateCovenantRequestPacket();
|
|
if(type == PacketType.EstateCovenantReply) return new EstateCovenantReplyPacket();
|
|
if(type == PacketType.ForceObjectSelect) return new ForceObjectSelectPacket();
|
|
if(type == PacketType.ParcelBuyPass) return new ParcelBuyPassPacket();
|
|
if(type == PacketType.ParcelDeedToGroup) return new ParcelDeedToGroupPacket();
|
|
if(type == PacketType.ParcelReclaim) return new ParcelReclaimPacket();
|
|
if(type == PacketType.ParcelClaim) return new ParcelClaimPacket();
|
|
if(type == PacketType.ParcelJoin) return new ParcelJoinPacket();
|
|
if(type == PacketType.ParcelDivide) return new ParcelDividePacket();
|
|
if(type == PacketType.ParcelRelease) return new ParcelReleasePacket();
|
|
if(type == PacketType.ParcelBuy) return new ParcelBuyPacket();
|
|
if(type == PacketType.ParcelGodForceOwner) return new ParcelGodForceOwnerPacket();
|
|
if(type == PacketType.ParcelAccessListRequest) return new ParcelAccessListRequestPacket();
|
|
if(type == PacketType.ParcelAccessListReply) return new ParcelAccessListReplyPacket();
|
|
if(type == PacketType.ParcelAccessListUpdate) return new ParcelAccessListUpdatePacket();
|
|
if(type == PacketType.ParcelDwellRequest) return new ParcelDwellRequestPacket();
|
|
if(type == PacketType.ParcelDwellReply) return new ParcelDwellReplyPacket();
|
|
if(type == PacketType.ParcelGodMarkAsContent) return new ParcelGodMarkAsContentPacket();
|
|
if(type == PacketType.ViewerStartAuction) return new ViewerStartAuctionPacket();
|
|
if(type == PacketType.UUIDNameRequest) return new UUIDNameRequestPacket();
|
|
if(type == PacketType.UUIDNameReply) return new UUIDNameReplyPacket();
|
|
if(type == PacketType.UUIDGroupNameRequest) return new UUIDGroupNameRequestPacket();
|
|
if(type == PacketType.UUIDGroupNameReply) return new UUIDGroupNameReplyPacket();
|
|
if(type == PacketType.ChildAgentDying) return new ChildAgentDyingPacket();
|
|
if(type == PacketType.ChildAgentUnknown) return new ChildAgentUnknownPacket();
|
|
if(type == PacketType.GetScriptRunning) return new GetScriptRunningPacket();
|
|
if(type == PacketType.ScriptRunningReply) return new ScriptRunningReplyPacket();
|
|
if(type == PacketType.SetScriptRunning) return new SetScriptRunningPacket();
|
|
if(type == PacketType.ScriptReset) return new ScriptResetPacket();
|
|
if(type == PacketType.ScriptSensorRequest) return new ScriptSensorRequestPacket();
|
|
if(type == PacketType.ScriptSensorReply) return new ScriptSensorReplyPacket();
|
|
if(type == PacketType.CompleteAgentMovement) return new CompleteAgentMovementPacket();
|
|
if(type == PacketType.AgentMovementComplete) return new AgentMovementCompletePacket();
|
|
if(type == PacketType.LogoutRequest) return new LogoutRequestPacket();
|
|
if(type == PacketType.LogoutReply) return new LogoutReplyPacket();
|
|
if(type == PacketType.ImprovedInstantMessage) return new ImprovedInstantMessagePacket();
|
|
if(type == PacketType.RetrieveInstantMessages) return new RetrieveInstantMessagesPacket();
|
|
if(type == PacketType.FindAgent) return new FindAgentPacket();
|
|
if(type == PacketType.RequestGodlikePowers) return new RequestGodlikePowersPacket();
|
|
if(type == PacketType.GrantGodlikePowers) return new GrantGodlikePowersPacket();
|
|
if(type == PacketType.GodlikeMessage) return new GodlikeMessagePacket();
|
|
if(type == PacketType.EstateOwnerMessage) return new EstateOwnerMessagePacket();
|
|
if(type == PacketType.GenericMessage) return new GenericMessagePacket();
|
|
if(type == PacketType.MuteListRequest) return new MuteListRequestPacket();
|
|
if(type == PacketType.UpdateMuteListEntry) return new UpdateMuteListEntryPacket();
|
|
if(type == PacketType.RemoveMuteListEntry) return new RemoveMuteListEntryPacket();
|
|
if(type == PacketType.CopyInventoryFromNotecard) return new CopyInventoryFromNotecardPacket();
|
|
if(type == PacketType.UpdateInventoryItem) return new UpdateInventoryItemPacket();
|
|
if(type == PacketType.UpdateCreateInventoryItem) return new UpdateCreateInventoryItemPacket();
|
|
if(type == PacketType.MoveInventoryItem) return new MoveInventoryItemPacket();
|
|
if(type == PacketType.CopyInventoryItem) return new CopyInventoryItemPacket();
|
|
if(type == PacketType.RemoveInventoryItem) return new RemoveInventoryItemPacket();
|
|
if(type == PacketType.ChangeInventoryItemFlags) return new ChangeInventoryItemFlagsPacket();
|
|
if(type == PacketType.SaveAssetIntoInventory) return new SaveAssetIntoInventoryPacket();
|
|
if(type == PacketType.CreateInventoryFolder) return new CreateInventoryFolderPacket();
|
|
if(type == PacketType.UpdateInventoryFolder) return new UpdateInventoryFolderPacket();
|
|
if(type == PacketType.MoveInventoryFolder) return new MoveInventoryFolderPacket();
|
|
if(type == PacketType.RemoveInventoryFolder) return new RemoveInventoryFolderPacket();
|
|
if(type == PacketType.FetchInventoryDescendents) return new FetchInventoryDescendentsPacket();
|
|
if(type == PacketType.InventoryDescendents) return new InventoryDescendentsPacket();
|
|
if(type == PacketType.FetchInventory) return new FetchInventoryPacket();
|
|
if(type == PacketType.FetchInventoryReply) return new FetchInventoryReplyPacket();
|
|
if(type == PacketType.BulkUpdateInventory) return new BulkUpdateInventoryPacket();
|
|
if(type == PacketType.RequestInventoryAsset) return new RequestInventoryAssetPacket();
|
|
if(type == PacketType.InventoryAssetResponse) return new InventoryAssetResponsePacket();
|
|
if(type == PacketType.RemoveInventoryObjects) return new RemoveInventoryObjectsPacket();
|
|
if(type == PacketType.PurgeInventoryDescendents) return new PurgeInventoryDescendentsPacket();
|
|
if(type == PacketType.UpdateTaskInventory) return new UpdateTaskInventoryPacket();
|
|
if(type == PacketType.RemoveTaskInventory) return new RemoveTaskInventoryPacket();
|
|
if(type == PacketType.MoveTaskInventory) return new MoveTaskInventoryPacket();
|
|
if(type == PacketType.RequestTaskInventory) return new RequestTaskInventoryPacket();
|
|
if(type == PacketType.ReplyTaskInventory) return new ReplyTaskInventoryPacket();
|
|
if(type == PacketType.DeRezObject) return new DeRezObjectPacket();
|
|
if(type == PacketType.DeRezAck) return new DeRezAckPacket();
|
|
if(type == PacketType.RezObject) return new RezObjectPacket();
|
|
if(type == PacketType.RezObjectFromNotecard) return new RezObjectFromNotecardPacket();
|
|
if(type == PacketType.AcceptFriendship) return new AcceptFriendshipPacket();
|
|
if(type == PacketType.DeclineFriendship) return new DeclineFriendshipPacket();
|
|
if(type == PacketType.FormFriendship) return new FormFriendshipPacket();
|
|
if(type == PacketType.TerminateFriendship) return new TerminateFriendshipPacket();
|
|
if(type == PacketType.OfferCallingCard) return new OfferCallingCardPacket();
|
|
if(type == PacketType.AcceptCallingCard) return new AcceptCallingCardPacket();
|
|
if(type == PacketType.DeclineCallingCard) return new DeclineCallingCardPacket();
|
|
if(type == PacketType.RezScript) return new RezScriptPacket();
|
|
if(type == PacketType.CreateInventoryItem) return new CreateInventoryItemPacket();
|
|
if(type == PacketType.CreateLandmarkForEvent) return new CreateLandmarkForEventPacket();
|
|
if(type == PacketType.RegionHandleRequest) return new RegionHandleRequestPacket();
|
|
if(type == PacketType.RegionIDAndHandleReply) return new RegionIDAndHandleReplyPacket();
|
|
if(type == PacketType.MoneyTransferRequest) return new MoneyTransferRequestPacket();
|
|
if(type == PacketType.MoneyBalanceRequest) return new MoneyBalanceRequestPacket();
|
|
if(type == PacketType.MoneyBalanceReply) return new MoneyBalanceReplyPacket();
|
|
if(type == PacketType.RoutedMoneyBalanceReply) return new RoutedMoneyBalanceReplyPacket();
|
|
if(type == PacketType.ActivateGestures) return new ActivateGesturesPacket();
|
|
if(type == PacketType.DeactivateGestures) return new DeactivateGesturesPacket();
|
|
if(type == PacketType.MuteListUpdate) return new MuteListUpdatePacket();
|
|
if(type == PacketType.UseCachedMuteList) return new UseCachedMuteListPacket();
|
|
if(type == PacketType.GrantUserRights) return new GrantUserRightsPacket();
|
|
if(type == PacketType.ChangeUserRights) return new ChangeUserRightsPacket();
|
|
if(type == PacketType.OnlineNotification) return new OnlineNotificationPacket();
|
|
if(type == PacketType.OfflineNotification) return new OfflineNotificationPacket();
|
|
if(type == PacketType.SetStartLocationRequest) return new SetStartLocationRequestPacket();
|
|
if(type == PacketType.AssetUploadRequest) return new AssetUploadRequestPacket();
|
|
if(type == PacketType.AssetUploadComplete) return new AssetUploadCompletePacket();
|
|
if(type == PacketType.CreateGroupRequest) return new CreateGroupRequestPacket();
|
|
if(type == PacketType.CreateGroupReply) return new CreateGroupReplyPacket();
|
|
if(type == PacketType.UpdateGroupInfo) return new UpdateGroupInfoPacket();
|
|
if(type == PacketType.GroupRoleChanges) return new GroupRoleChangesPacket();
|
|
if(type == PacketType.JoinGroupRequest) return new JoinGroupRequestPacket();
|
|
if(type == PacketType.JoinGroupReply) return new JoinGroupReplyPacket();
|
|
if(type == PacketType.EjectGroupMemberRequest) return new EjectGroupMemberRequestPacket();
|
|
if(type == PacketType.EjectGroupMemberReply) return new EjectGroupMemberReplyPacket();
|
|
if(type == PacketType.LeaveGroupRequest) return new LeaveGroupRequestPacket();
|
|
if(type == PacketType.LeaveGroupReply) return new LeaveGroupReplyPacket();
|
|
if(type == PacketType.InviteGroupRequest) return new InviteGroupRequestPacket();
|
|
if(type == PacketType.GroupProfileRequest) return new GroupProfileRequestPacket();
|
|
if(type == PacketType.GroupProfileReply) return new GroupProfileReplyPacket();
|
|
if(type == PacketType.GroupAccountSummaryRequest) return new GroupAccountSummaryRequestPacket();
|
|
if(type == PacketType.GroupAccountSummaryReply) return new GroupAccountSummaryReplyPacket();
|
|
if(type == PacketType.GroupAccountDetailsRequest) return new GroupAccountDetailsRequestPacket();
|
|
if(type == PacketType.GroupAccountDetailsReply) return new GroupAccountDetailsReplyPacket();
|
|
if(type == PacketType.GroupAccountTransactionsRequest) return new GroupAccountTransactionsRequestPacket();
|
|
if(type == PacketType.GroupAccountTransactionsReply) return new GroupAccountTransactionsReplyPacket();
|
|
if(type == PacketType.GroupActiveProposalsRequest) return new GroupActiveProposalsRequestPacket();
|
|
if(type == PacketType.GroupActiveProposalItemReply) return new GroupActiveProposalItemReplyPacket();
|
|
if(type == PacketType.GroupVoteHistoryRequest) return new GroupVoteHistoryRequestPacket();
|
|
if(type == PacketType.GroupVoteHistoryItemReply) return new GroupVoteHistoryItemReplyPacket();
|
|
if(type == PacketType.StartGroupProposal) return new StartGroupProposalPacket();
|
|
if(type == PacketType.GroupProposalBallot) return new GroupProposalBallotPacket();
|
|
if(type == PacketType.GroupMembersRequest) return new GroupMembersRequestPacket();
|
|
if(type == PacketType.GroupMembersReply) return new GroupMembersReplyPacket();
|
|
if(type == PacketType.ActivateGroup) return new ActivateGroupPacket();
|
|
if(type == PacketType.SetGroupContribution) return new SetGroupContributionPacket();
|
|
if(type == PacketType.SetGroupAcceptNotices) return new SetGroupAcceptNoticesPacket();
|
|
if(type == PacketType.GroupRoleDataRequest) return new GroupRoleDataRequestPacket();
|
|
if(type == PacketType.GroupRoleDataReply) return new GroupRoleDataReplyPacket();
|
|
if(type == PacketType.GroupRoleMembersRequest) return new GroupRoleMembersRequestPacket();
|
|
if(type == PacketType.GroupRoleMembersReply) return new GroupRoleMembersReplyPacket();
|
|
if(type == PacketType.GroupTitlesRequest) return new GroupTitlesRequestPacket();
|
|
if(type == PacketType.GroupTitlesReply) return new GroupTitlesReplyPacket();
|
|
if(type == PacketType.GroupTitleUpdate) return new GroupTitleUpdatePacket();
|
|
if(type == PacketType.GroupRoleUpdate) return new GroupRoleUpdatePacket();
|
|
if(type == PacketType.LiveHelpGroupRequest) return new LiveHelpGroupRequestPacket();
|
|
if(type == PacketType.LiveHelpGroupReply) return new LiveHelpGroupReplyPacket();
|
|
if(type == PacketType.AgentWearablesRequest) return new AgentWearablesRequestPacket();
|
|
if(type == PacketType.AgentWearablesUpdate) return new AgentWearablesUpdatePacket();
|
|
if(type == PacketType.AgentIsNowWearing) return new AgentIsNowWearingPacket();
|
|
if(type == PacketType.AgentCachedTexture) return new AgentCachedTexturePacket();
|
|
if(type == PacketType.AgentCachedTextureResponse) return new AgentCachedTextureResponsePacket();
|
|
if(type == PacketType.AgentDataUpdateRequest) return new AgentDataUpdateRequestPacket();
|
|
if(type == PacketType.AgentDataUpdate) return new AgentDataUpdatePacket();
|
|
if(type == PacketType.GroupDataUpdate) return new GroupDataUpdatePacket();
|
|
if(type == PacketType.AgentGroupDataUpdate) return new AgentGroupDataUpdatePacket();
|
|
if(type == PacketType.AgentDropGroup) return new AgentDropGroupPacket();
|
|
if(type == PacketType.CreateTrustedCircuit) return new CreateTrustedCircuitPacket();
|
|
if(type == PacketType.DenyTrustedCircuit) return new DenyTrustedCircuitPacket();
|
|
if(type == PacketType.RequestTrustedCircuit) return new RequestTrustedCircuitPacket();
|
|
if(type == PacketType.RezSingleAttachmentFromInv) return new RezSingleAttachmentFromInvPacket();
|
|
if(type == PacketType.RezMultipleAttachmentsFromInv) return new RezMultipleAttachmentsFromInvPacket();
|
|
if(type == PacketType.DetachAttachmentIntoInv) return new DetachAttachmentIntoInvPacket();
|
|
if(type == PacketType.CreateNewOutfitAttachments) return new CreateNewOutfitAttachmentsPacket();
|
|
if(type == PacketType.UserInfoRequest) return new UserInfoRequestPacket();
|
|
if(type == PacketType.UserInfoReply) return new UserInfoReplyPacket();
|
|
if(type == PacketType.UpdateUserInfo) return new UpdateUserInfoPacket();
|
|
if(type == PacketType.InitiateDownload) return new InitiateDownloadPacket();
|
|
if(type == PacketType.SystemMessage) return new SystemMessagePacket();
|
|
if(type == PacketType.MapLayerRequest) return new MapLayerRequestPacket();
|
|
if(type == PacketType.MapLayerReply) return new MapLayerReplyPacket();
|
|
if(type == PacketType.MapBlockRequest) return new MapBlockRequestPacket();
|
|
if(type == PacketType.MapNameRequest) return new MapNameRequestPacket();
|
|
if(type == PacketType.MapBlockReply) return new MapBlockReplyPacket();
|
|
if(type == PacketType.MapItemRequest) return new MapItemRequestPacket();
|
|
if(type == PacketType.MapItemReply) return new MapItemReplyPacket();
|
|
if(type == PacketType.SendPostcard) return new SendPostcardPacket();
|
|
if(type == PacketType.ParcelMediaCommandMessage) return new ParcelMediaCommandMessagePacket();
|
|
if(type == PacketType.ParcelMediaUpdate) return new ParcelMediaUpdatePacket();
|
|
if(type == PacketType.LandStatRequest) return new LandStatRequestPacket();
|
|
if(type == PacketType.LandStatReply) return new LandStatReplyPacket();
|
|
if(type == PacketType.Error) return new ErrorPacket();
|
|
if(type == PacketType.ObjectIncludeInSearch) return new ObjectIncludeInSearchPacket();
|
|
if(type == PacketType.PacketAck) return new PacketAckPacket();
|
|
if(type == PacketType.OpenCircuit) return new OpenCircuitPacket();
|
|
if(type == PacketType.CloseCircuit) return new CloseCircuitPacket();
|
|
return null;
|
|
|
|
}
|
|
|
|
public static Packet BuildPacket(byte[] packetBuffer, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
byte[] bytes; ushort id; PacketFrequency freq;
|
|
int i = 0;
|
|
Header header = Header.BuildHeader(packetBuffer, ref i, ref packetEnd);
|
|
if (header.Zerocoded)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(packetBuffer, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
else
|
|
{
|
|
bytes = packetBuffer;
|
|
}
|
|
|
|
if (bytes[6] == 0xFF)
|
|
{
|
|
if (bytes[7] == 0xFF)
|
|
{
|
|
id = (ushort)((bytes[8] << 8) + bytes[9]); freq = PacketFrequency.Low;
|
|
switch (id)
|
|
{
|
|
case 1: return new TestMessagePacket(header, bytes, ref i);
|
|
case 3: return new UseCircuitCodePacket(header, bytes, ref i);
|
|
case 10: return new TelehubInfoPacket(header, bytes, ref i);
|
|
case 24: return new EconomyDataRequestPacket(header, bytes, ref i);
|
|
case 25: return new EconomyDataPacket(header, bytes, ref i);
|
|
case 26: return new AvatarPickerRequestPacket(header, bytes, ref i);
|
|
case 28: return new AvatarPickerReplyPacket(header, bytes, ref i);
|
|
case 29: return new PlacesQueryPacket(header, bytes, ref i);
|
|
case 30: return new PlacesReplyPacket(header, bytes, ref i);
|
|
case 31: return new DirFindQueryPacket(header, bytes, ref i);
|
|
case 33: return new DirPlacesQueryPacket(header, bytes, ref i);
|
|
case 35: return new DirPlacesReplyPacket(header, bytes, ref i);
|
|
case 36: return new DirPeopleReplyPacket(header, bytes, ref i);
|
|
case 37: return new DirEventsReplyPacket(header, bytes, ref i);
|
|
case 38: return new DirGroupsReplyPacket(header, bytes, ref i);
|
|
case 39: return new DirClassifiedQueryPacket(header, bytes, ref i);
|
|
case 41: return new DirClassifiedReplyPacket(header, bytes, ref i);
|
|
case 42: return new AvatarClassifiedReplyPacket(header, bytes, ref i);
|
|
case 43: return new ClassifiedInfoRequestPacket(header, bytes, ref i);
|
|
case 44: return new ClassifiedInfoReplyPacket(header, bytes, ref i);
|
|
case 45: return new ClassifiedInfoUpdatePacket(header, bytes, ref i);
|
|
case 46: return new ClassifiedDeletePacket(header, bytes, ref i);
|
|
case 47: return new ClassifiedGodDeletePacket(header, bytes, ref i);
|
|
case 48: return new DirLandQueryPacket(header, bytes, ref i);
|
|
case 50: return new DirLandReplyPacket(header, bytes, ref i);
|
|
case 51: return new DirPopularQueryPacket(header, bytes, ref i);
|
|
case 53: return new DirPopularReplyPacket(header, bytes, ref i);
|
|
case 54: return new ParcelInfoRequestPacket(header, bytes, ref i);
|
|
case 55: return new ParcelInfoReplyPacket(header, bytes, ref i);
|
|
case 56: return new ParcelObjectOwnersRequestPacket(header, bytes, ref i);
|
|
case 57: return new ParcelObjectOwnersReplyPacket(header, bytes, ref i);
|
|
case 58: return new GroupNoticesListRequestPacket(header, bytes, ref i);
|
|
case 59: return new GroupNoticesListReplyPacket(header, bytes, ref i);
|
|
case 60: return new GroupNoticeRequestPacket(header, bytes, ref i);
|
|
case 62: return new TeleportRequestPacket(header, bytes, ref i);
|
|
case 63: return new TeleportLocationRequestPacket(header, bytes, ref i);
|
|
case 64: return new TeleportLocalPacket(header, bytes, ref i);
|
|
case 65: return new TeleportLandmarkRequestPacket(header, bytes, ref i);
|
|
case 66: return new TeleportProgressPacket(header, bytes, ref i);
|
|
case 69: return new TeleportFinishPacket(header, bytes, ref i);
|
|
case 70: return new StartLurePacket(header, bytes, ref i);
|
|
case 71: return new TeleportLureRequestPacket(header, bytes, ref i);
|
|
case 72: return new TeleportCancelPacket(header, bytes, ref i);
|
|
case 73: return new TeleportStartPacket(header, bytes, ref i);
|
|
case 74: return new TeleportFailedPacket(header, bytes, ref i);
|
|
case 75: return new UndoPacket(header, bytes, ref i);
|
|
case 76: return new RedoPacket(header, bytes, ref i);
|
|
case 77: return new UndoLandPacket(header, bytes, ref i);
|
|
case 78: return new AgentPausePacket(header, bytes, ref i);
|
|
case 79: return new AgentResumePacket(header, bytes, ref i);
|
|
case 80: return new ChatFromViewerPacket(header, bytes, ref i);
|
|
case 81: return new AgentThrottlePacket(header, bytes, ref i);
|
|
case 82: return new AgentFOVPacket(header, bytes, ref i);
|
|
case 83: return new AgentHeightWidthPacket(header, bytes, ref i);
|
|
case 84: return new AgentSetAppearancePacket(header, bytes, ref i);
|
|
case 85: return new AgentQuitCopyPacket(header, bytes, ref i);
|
|
case 86: return new ImageNotInDatabasePacket(header, bytes, ref i);
|
|
case 87: return new RebakeAvatarTexturesPacket(header, bytes, ref i);
|
|
case 88: return new SetAlwaysRunPacket(header, bytes, ref i);
|
|
case 89: return new ObjectDeletePacket(header, bytes, ref i);
|
|
case 90: return new ObjectDuplicatePacket(header, bytes, ref i);
|
|
case 91: return new ObjectDuplicateOnRayPacket(header, bytes, ref i);
|
|
case 92: return new ObjectScalePacket(header, bytes, ref i);
|
|
case 93: return new ObjectRotationPacket(header, bytes, ref i);
|
|
case 94: return new ObjectFlagUpdatePacket(header, bytes, ref i);
|
|
case 95: return new ObjectClickActionPacket(header, bytes, ref i);
|
|
case 96: return new ObjectImagePacket(header, bytes, ref i);
|
|
case 97: return new ObjectMaterialPacket(header, bytes, ref i);
|
|
case 98: return new ObjectShapePacket(header, bytes, ref i);
|
|
case 99: return new ObjectExtraParamsPacket(header, bytes, ref i);
|
|
case 100: return new ObjectOwnerPacket(header, bytes, ref i);
|
|
case 101: return new ObjectGroupPacket(header, bytes, ref i);
|
|
case 102: return new ObjectBuyPacket(header, bytes, ref i);
|
|
case 103: return new BuyObjectInventoryPacket(header, bytes, ref i);
|
|
case 104: return new DerezContainerPacket(header, bytes, ref i);
|
|
case 105: return new ObjectPermissionsPacket(header, bytes, ref i);
|
|
case 106: return new ObjectSaleInfoPacket(header, bytes, ref i);
|
|
case 107: return new ObjectNamePacket(header, bytes, ref i);
|
|
case 108: return new ObjectDescriptionPacket(header, bytes, ref i);
|
|
case 109: return new ObjectCategoryPacket(header, bytes, ref i);
|
|
case 110: return new ObjectSelectPacket(header, bytes, ref i);
|
|
case 111: return new ObjectDeselectPacket(header, bytes, ref i);
|
|
case 112: return new ObjectAttachPacket(header, bytes, ref i);
|
|
case 113: return new ObjectDetachPacket(header, bytes, ref i);
|
|
case 114: return new ObjectDropPacket(header, bytes, ref i);
|
|
case 115: return new ObjectLinkPacket(header, bytes, ref i);
|
|
case 116: return new ObjectDelinkPacket(header, bytes, ref i);
|
|
case 117: return new ObjectGrabPacket(header, bytes, ref i);
|
|
case 118: return new ObjectGrabUpdatePacket(header, bytes, ref i);
|
|
case 119: return new ObjectDeGrabPacket(header, bytes, ref i);
|
|
case 120: return new ObjectSpinStartPacket(header, bytes, ref i);
|
|
case 121: return new ObjectSpinUpdatePacket(header, bytes, ref i);
|
|
case 122: return new ObjectSpinStopPacket(header, bytes, ref i);
|
|
case 123: return new ObjectExportSelectedPacket(header, bytes, ref i);
|
|
case 124: return new ModifyLandPacket(header, bytes, ref i);
|
|
case 125: return new VelocityInterpolateOnPacket(header, bytes, ref i);
|
|
case 126: return new VelocityInterpolateOffPacket(header, bytes, ref i);
|
|
case 127: return new StateSavePacket(header, bytes, ref i);
|
|
case 128: return new ReportAutosaveCrashPacket(header, bytes, ref i);
|
|
case 129: return new SimWideDeletesPacket(header, bytes, ref i);
|
|
case 130: return new TrackAgentPacket(header, bytes, ref i);
|
|
case 131: return new ViewerStatsPacket(header, bytes, ref i);
|
|
case 132: return new ScriptAnswerYesPacket(header, bytes, ref i);
|
|
case 133: return new UserReportPacket(header, bytes, ref i);
|
|
case 134: return new AlertMessagePacket(header, bytes, ref i);
|
|
case 135: return new AgentAlertMessagePacket(header, bytes, ref i);
|
|
case 136: return new MeanCollisionAlertPacket(header, bytes, ref i);
|
|
case 137: return new ViewerFrozenMessagePacket(header, bytes, ref i);
|
|
case 138: return new HealthMessagePacket(header, bytes, ref i);
|
|
case 139: return new ChatFromSimulatorPacket(header, bytes, ref i);
|
|
case 140: return new SimStatsPacket(header, bytes, ref i);
|
|
case 141: return new RequestRegionInfoPacket(header, bytes, ref i);
|
|
case 142: return new RegionInfoPacket(header, bytes, ref i);
|
|
case 143: return new GodUpdateRegionInfoPacket(header, bytes, ref i);
|
|
case 146: return new NearestLandingRegionUpdatedPacket(header, bytes, ref i);
|
|
case 148: return new RegionHandshakePacket(header, bytes, ref i);
|
|
case 149: return new RegionHandshakeReplyPacket(header, bytes, ref i);
|
|
case 150: return new SimulatorViewerTimeMessagePacket(header, bytes, ref i);
|
|
case 151: return new EnableSimulatorPacket(header, bytes, ref i);
|
|
case 152: return new DisableSimulatorPacket(header, bytes, ref i);
|
|
case 153: return new TransferRequestPacket(header, bytes, ref i);
|
|
case 154: return new TransferInfoPacket(header, bytes, ref i);
|
|
case 155: return new TransferAbortPacket(header, bytes, ref i);
|
|
case 156: return new RequestXferPacket(header, bytes, ref i);
|
|
case 157: return new AbortXferPacket(header, bytes, ref i);
|
|
case 158: return new AvatarAppearancePacket(header, bytes, ref i);
|
|
case 159: return new SetFollowCamPropertiesPacket(header, bytes, ref i);
|
|
case 160: return new ClearFollowCamPropertiesPacket(header, bytes, ref i);
|
|
case 161: return new RequestPayPricePacket(header, bytes, ref i);
|
|
case 162: return new PayPriceReplyPacket(header, bytes, ref i);
|
|
case 163: return new KickUserPacket(header, bytes, ref i);
|
|
case 164: return new KickUserAckPacket(header, bytes, ref i);
|
|
case 165: return new GodKickUserPacket(header, bytes, ref i);
|
|
case 167: return new EjectUserPacket(header, bytes, ref i);
|
|
case 168: return new FreezeUserPacket(header, bytes, ref i);
|
|
case 169: return new AvatarPropertiesRequestPacket(header, bytes, ref i);
|
|
case 171: return new AvatarPropertiesReplyPacket(header, bytes, ref i);
|
|
case 172: return new AvatarInterestsReplyPacket(header, bytes, ref i);
|
|
case 173: return new AvatarGroupsReplyPacket(header, bytes, ref i);
|
|
case 174: return new AvatarPropertiesUpdatePacket(header, bytes, ref i);
|
|
case 175: return new AvatarInterestsUpdatePacket(header, bytes, ref i);
|
|
case 176: return new AvatarNotesReplyPacket(header, bytes, ref i);
|
|
case 177: return new AvatarNotesUpdatePacket(header, bytes, ref i);
|
|
case 178: return new AvatarPicksReplyPacket(header, bytes, ref i);
|
|
case 179: return new EventInfoRequestPacket(header, bytes, ref i);
|
|
case 180: return new EventInfoReplyPacket(header, bytes, ref i);
|
|
case 181: return new EventNotificationAddRequestPacket(header, bytes, ref i);
|
|
case 182: return new EventNotificationRemoveRequestPacket(header, bytes, ref i);
|
|
case 183: return new EventGodDeletePacket(header, bytes, ref i);
|
|
case 184: return new PickInfoReplyPacket(header, bytes, ref i);
|
|
case 185: return new PickInfoUpdatePacket(header, bytes, ref i);
|
|
case 186: return new PickDeletePacket(header, bytes, ref i);
|
|
case 187: return new PickGodDeletePacket(header, bytes, ref i);
|
|
case 188: return new ScriptQuestionPacket(header, bytes, ref i);
|
|
case 189: return new ScriptControlChangePacket(header, bytes, ref i);
|
|
case 190: return new ScriptDialogPacket(header, bytes, ref i);
|
|
case 191: return new ScriptDialogReplyPacket(header, bytes, ref i);
|
|
case 192: return new ForceScriptControlReleasePacket(header, bytes, ref i);
|
|
case 193: return new RevokePermissionsPacket(header, bytes, ref i);
|
|
case 194: return new LoadURLPacket(header, bytes, ref i);
|
|
case 195: return new ScriptTeleportRequestPacket(header, bytes, ref i);
|
|
case 196: return new ParcelOverlayPacket(header, bytes, ref i);
|
|
case 197: return new ParcelPropertiesRequestByIDPacket(header, bytes, ref i);
|
|
case 198: return new ParcelPropertiesUpdatePacket(header, bytes, ref i);
|
|
case 199: return new ParcelReturnObjectsPacket(header, bytes, ref i);
|
|
case 200: return new ParcelSetOtherCleanTimePacket(header, bytes, ref i);
|
|
case 201: return new ParcelDisableObjectsPacket(header, bytes, ref i);
|
|
case 202: return new ParcelSelectObjectsPacket(header, bytes, ref i);
|
|
case 203: return new EstateCovenantRequestPacket(header, bytes, ref i);
|
|
case 204: return new EstateCovenantReplyPacket(header, bytes, ref i);
|
|
case 205: return new ForceObjectSelectPacket(header, bytes, ref i);
|
|
case 206: return new ParcelBuyPassPacket(header, bytes, ref i);
|
|
case 207: return new ParcelDeedToGroupPacket(header, bytes, ref i);
|
|
case 208: return new ParcelReclaimPacket(header, bytes, ref i);
|
|
case 209: return new ParcelClaimPacket(header, bytes, ref i);
|
|
case 210: return new ParcelJoinPacket(header, bytes, ref i);
|
|
case 211: return new ParcelDividePacket(header, bytes, ref i);
|
|
case 212: return new ParcelReleasePacket(header, bytes, ref i);
|
|
case 213: return new ParcelBuyPacket(header, bytes, ref i);
|
|
case 214: return new ParcelGodForceOwnerPacket(header, bytes, ref i);
|
|
case 215: return new ParcelAccessListRequestPacket(header, bytes, ref i);
|
|
case 216: return new ParcelAccessListReplyPacket(header, bytes, ref i);
|
|
case 217: return new ParcelAccessListUpdatePacket(header, bytes, ref i);
|
|
case 218: return new ParcelDwellRequestPacket(header, bytes, ref i);
|
|
case 219: return new ParcelDwellReplyPacket(header, bytes, ref i);
|
|
case 227: return new ParcelGodMarkAsContentPacket(header, bytes, ref i);
|
|
case 228: return new ViewerStartAuctionPacket(header, bytes, ref i);
|
|
case 235: return new UUIDNameRequestPacket(header, bytes, ref i);
|
|
case 236: return new UUIDNameReplyPacket(header, bytes, ref i);
|
|
case 237: return new UUIDGroupNameRequestPacket(header, bytes, ref i);
|
|
case 238: return new UUIDGroupNameReplyPacket(header, bytes, ref i);
|
|
case 240: return new ChildAgentDyingPacket(header, bytes, ref i);
|
|
case 241: return new ChildAgentUnknownPacket(header, bytes, ref i);
|
|
case 243: return new GetScriptRunningPacket(header, bytes, ref i);
|
|
case 244: return new ScriptRunningReplyPacket(header, bytes, ref i);
|
|
case 245: return new SetScriptRunningPacket(header, bytes, ref i);
|
|
case 246: return new ScriptResetPacket(header, bytes, ref i);
|
|
case 247: return new ScriptSensorRequestPacket(header, bytes, ref i);
|
|
case 248: return new ScriptSensorReplyPacket(header, bytes, ref i);
|
|
case 249: return new CompleteAgentMovementPacket(header, bytes, ref i);
|
|
case 250: return new AgentMovementCompletePacket(header, bytes, ref i);
|
|
case 252: return new LogoutRequestPacket(header, bytes, ref i);
|
|
case 253: return new LogoutReplyPacket(header, bytes, ref i);
|
|
case 254: return new ImprovedInstantMessagePacket(header, bytes, ref i);
|
|
case 255: return new RetrieveInstantMessagesPacket(header, bytes, ref i);
|
|
case 256: return new FindAgentPacket(header, bytes, ref i);
|
|
case 257: return new RequestGodlikePowersPacket(header, bytes, ref i);
|
|
case 258: return new GrantGodlikePowersPacket(header, bytes, ref i);
|
|
case 259: return new GodlikeMessagePacket(header, bytes, ref i);
|
|
case 260: return new EstateOwnerMessagePacket(header, bytes, ref i);
|
|
case 261: return new GenericMessagePacket(header, bytes, ref i);
|
|
case 262: return new MuteListRequestPacket(header, bytes, ref i);
|
|
case 263: return new UpdateMuteListEntryPacket(header, bytes, ref i);
|
|
case 264: return new RemoveMuteListEntryPacket(header, bytes, ref i);
|
|
case 265: return new CopyInventoryFromNotecardPacket(header, bytes, ref i);
|
|
case 266: return new UpdateInventoryItemPacket(header, bytes, ref i);
|
|
case 267: return new UpdateCreateInventoryItemPacket(header, bytes, ref i);
|
|
case 268: return new MoveInventoryItemPacket(header, bytes, ref i);
|
|
case 269: return new CopyInventoryItemPacket(header, bytes, ref i);
|
|
case 270: return new RemoveInventoryItemPacket(header, bytes, ref i);
|
|
case 271: return new ChangeInventoryItemFlagsPacket(header, bytes, ref i);
|
|
case 272: return new SaveAssetIntoInventoryPacket(header, bytes, ref i);
|
|
case 273: return new CreateInventoryFolderPacket(header, bytes, ref i);
|
|
case 274: return new UpdateInventoryFolderPacket(header, bytes, ref i);
|
|
case 275: return new MoveInventoryFolderPacket(header, bytes, ref i);
|
|
case 276: return new RemoveInventoryFolderPacket(header, bytes, ref i);
|
|
case 277: return new FetchInventoryDescendentsPacket(header, bytes, ref i);
|
|
case 278: return new InventoryDescendentsPacket(header, bytes, ref i);
|
|
case 279: return new FetchInventoryPacket(header, bytes, ref i);
|
|
case 280: return new FetchInventoryReplyPacket(header, bytes, ref i);
|
|
case 281: return new BulkUpdateInventoryPacket(header, bytes, ref i);
|
|
case 282: return new RequestInventoryAssetPacket(header, bytes, ref i);
|
|
case 283: return new InventoryAssetResponsePacket(header, bytes, ref i);
|
|
case 284: return new RemoveInventoryObjectsPacket(header, bytes, ref i);
|
|
case 285: return new PurgeInventoryDescendentsPacket(header, bytes, ref i);
|
|
case 286: return new UpdateTaskInventoryPacket(header, bytes, ref i);
|
|
case 287: return new RemoveTaskInventoryPacket(header, bytes, ref i);
|
|
case 288: return new MoveTaskInventoryPacket(header, bytes, ref i);
|
|
case 289: return new RequestTaskInventoryPacket(header, bytes, ref i);
|
|
case 290: return new ReplyTaskInventoryPacket(header, bytes, ref i);
|
|
case 291: return new DeRezObjectPacket(header, bytes, ref i);
|
|
case 292: return new DeRezAckPacket(header, bytes, ref i);
|
|
case 293: return new RezObjectPacket(header, bytes, ref i);
|
|
case 294: return new RezObjectFromNotecardPacket(header, bytes, ref i);
|
|
case 297: return new AcceptFriendshipPacket(header, bytes, ref i);
|
|
case 298: return new DeclineFriendshipPacket(header, bytes, ref i);
|
|
case 299: return new FormFriendshipPacket(header, bytes, ref i);
|
|
case 300: return new TerminateFriendshipPacket(header, bytes, ref i);
|
|
case 301: return new OfferCallingCardPacket(header, bytes, ref i);
|
|
case 302: return new AcceptCallingCardPacket(header, bytes, ref i);
|
|
case 303: return new DeclineCallingCardPacket(header, bytes, ref i);
|
|
case 304: return new RezScriptPacket(header, bytes, ref i);
|
|
case 305: return new CreateInventoryItemPacket(header, bytes, ref i);
|
|
case 306: return new CreateLandmarkForEventPacket(header, bytes, ref i);
|
|
case 309: return new RegionHandleRequestPacket(header, bytes, ref i);
|
|
case 310: return new RegionIDAndHandleReplyPacket(header, bytes, ref i);
|
|
case 311: return new MoneyTransferRequestPacket(header, bytes, ref i);
|
|
case 313: return new MoneyBalanceRequestPacket(header, bytes, ref i);
|
|
case 314: return new MoneyBalanceReplyPacket(header, bytes, ref i);
|
|
case 315: return new RoutedMoneyBalanceReplyPacket(header, bytes, ref i);
|
|
case 316: return new ActivateGesturesPacket(header, bytes, ref i);
|
|
case 317: return new DeactivateGesturesPacket(header, bytes, ref i);
|
|
case 318: return new MuteListUpdatePacket(header, bytes, ref i);
|
|
case 319: return new UseCachedMuteListPacket(header, bytes, ref i);
|
|
case 320: return new GrantUserRightsPacket(header, bytes, ref i);
|
|
case 321: return new ChangeUserRightsPacket(header, bytes, ref i);
|
|
case 322: return new OnlineNotificationPacket(header, bytes, ref i);
|
|
case 323: return new OfflineNotificationPacket(header, bytes, ref i);
|
|
case 324: return new SetStartLocationRequestPacket(header, bytes, ref i);
|
|
case 333: return new AssetUploadRequestPacket(header, bytes, ref i);
|
|
case 334: return new AssetUploadCompletePacket(header, bytes, ref i);
|
|
case 339: return new CreateGroupRequestPacket(header, bytes, ref i);
|
|
case 340: return new CreateGroupReplyPacket(header, bytes, ref i);
|
|
case 341: return new UpdateGroupInfoPacket(header, bytes, ref i);
|
|
case 342: return new GroupRoleChangesPacket(header, bytes, ref i);
|
|
case 343: return new JoinGroupRequestPacket(header, bytes, ref i);
|
|
case 344: return new JoinGroupReplyPacket(header, bytes, ref i);
|
|
case 345: return new EjectGroupMemberRequestPacket(header, bytes, ref i);
|
|
case 346: return new EjectGroupMemberReplyPacket(header, bytes, ref i);
|
|
case 347: return new LeaveGroupRequestPacket(header, bytes, ref i);
|
|
case 348: return new LeaveGroupReplyPacket(header, bytes, ref i);
|
|
case 349: return new InviteGroupRequestPacket(header, bytes, ref i);
|
|
case 351: return new GroupProfileRequestPacket(header, bytes, ref i);
|
|
case 352: return new GroupProfileReplyPacket(header, bytes, ref i);
|
|
case 353: return new GroupAccountSummaryRequestPacket(header, bytes, ref i);
|
|
case 354: return new GroupAccountSummaryReplyPacket(header, bytes, ref i);
|
|
case 355: return new GroupAccountDetailsRequestPacket(header, bytes, ref i);
|
|
case 356: return new GroupAccountDetailsReplyPacket(header, bytes, ref i);
|
|
case 357: return new GroupAccountTransactionsRequestPacket(header, bytes, ref i);
|
|
case 358: return new GroupAccountTransactionsReplyPacket(header, bytes, ref i);
|
|
case 359: return new GroupActiveProposalsRequestPacket(header, bytes, ref i);
|
|
case 360: return new GroupActiveProposalItemReplyPacket(header, bytes, ref i);
|
|
case 361: return new GroupVoteHistoryRequestPacket(header, bytes, ref i);
|
|
case 362: return new GroupVoteHistoryItemReplyPacket(header, bytes, ref i);
|
|
case 363: return new StartGroupProposalPacket(header, bytes, ref i);
|
|
case 364: return new GroupProposalBallotPacket(header, bytes, ref i);
|
|
case 366: return new GroupMembersRequestPacket(header, bytes, ref i);
|
|
case 367: return new GroupMembersReplyPacket(header, bytes, ref i);
|
|
case 368: return new ActivateGroupPacket(header, bytes, ref i);
|
|
case 369: return new SetGroupContributionPacket(header, bytes, ref i);
|
|
case 370: return new SetGroupAcceptNoticesPacket(header, bytes, ref i);
|
|
case 371: return new GroupRoleDataRequestPacket(header, bytes, ref i);
|
|
case 372: return new GroupRoleDataReplyPacket(header, bytes, ref i);
|
|
case 373: return new GroupRoleMembersRequestPacket(header, bytes, ref i);
|
|
case 374: return new GroupRoleMembersReplyPacket(header, bytes, ref i);
|
|
case 375: return new GroupTitlesRequestPacket(header, bytes, ref i);
|
|
case 376: return new GroupTitlesReplyPacket(header, bytes, ref i);
|
|
case 377: return new GroupTitleUpdatePacket(header, bytes, ref i);
|
|
case 378: return new GroupRoleUpdatePacket(header, bytes, ref i);
|
|
case 379: return new LiveHelpGroupRequestPacket(header, bytes, ref i);
|
|
case 380: return new LiveHelpGroupReplyPacket(header, bytes, ref i);
|
|
case 381: return new AgentWearablesRequestPacket(header, bytes, ref i);
|
|
case 382: return new AgentWearablesUpdatePacket(header, bytes, ref i);
|
|
case 383: return new AgentIsNowWearingPacket(header, bytes, ref i);
|
|
case 384: return new AgentCachedTexturePacket(header, bytes, ref i);
|
|
case 385: return new AgentCachedTextureResponsePacket(header, bytes, ref i);
|
|
case 386: return new AgentDataUpdateRequestPacket(header, bytes, ref i);
|
|
case 387: return new AgentDataUpdatePacket(header, bytes, ref i);
|
|
case 388: return new GroupDataUpdatePacket(header, bytes, ref i);
|
|
case 389: return new AgentGroupDataUpdatePacket(header, bytes, ref i);
|
|
case 390: return new AgentDropGroupPacket(header, bytes, ref i);
|
|
case 392: return new CreateTrustedCircuitPacket(header, bytes, ref i);
|
|
case 393: return new DenyTrustedCircuitPacket(header, bytes, ref i);
|
|
case 394: return new RequestTrustedCircuitPacket(header, bytes, ref i);
|
|
case 395: return new RezSingleAttachmentFromInvPacket(header, bytes, ref i);
|
|
case 396: return new RezMultipleAttachmentsFromInvPacket(header, bytes, ref i);
|
|
case 397: return new DetachAttachmentIntoInvPacket(header, bytes, ref i);
|
|
case 398: return new CreateNewOutfitAttachmentsPacket(header, bytes, ref i);
|
|
case 399: return new UserInfoRequestPacket(header, bytes, ref i);
|
|
case 400: return new UserInfoReplyPacket(header, bytes, ref i);
|
|
case 401: return new UpdateUserInfoPacket(header, bytes, ref i);
|
|
case 403: return new InitiateDownloadPacket(header, bytes, ref i);
|
|
case 404: return new SystemMessagePacket(header, bytes, ref i);
|
|
case 405: return new MapLayerRequestPacket(header, bytes, ref i);
|
|
case 406: return new MapLayerReplyPacket(header, bytes, ref i);
|
|
case 407: return new MapBlockRequestPacket(header, bytes, ref i);
|
|
case 408: return new MapNameRequestPacket(header, bytes, ref i);
|
|
case 409: return new MapBlockReplyPacket(header, bytes, ref i);
|
|
case 410: return new MapItemRequestPacket(header, bytes, ref i);
|
|
case 411: return new MapItemReplyPacket(header, bytes, ref i);
|
|
case 412: return new SendPostcardPacket(header, bytes, ref i);
|
|
case 419: return new ParcelMediaCommandMessagePacket(header, bytes, ref i);
|
|
case 420: return new ParcelMediaUpdatePacket(header, bytes, ref i);
|
|
case 421: return new LandStatRequestPacket(header, bytes, ref i);
|
|
case 422: return new LandStatReplyPacket(header, bytes, ref i);
|
|
case 423: return new ErrorPacket(header, bytes, ref i);
|
|
case 424: return new ObjectIncludeInSearchPacket(header, bytes, ref i);
|
|
case 65531: return new PacketAckPacket(header, bytes, ref i);
|
|
case 65532: return new OpenCircuitPacket(header, bytes, ref i);
|
|
case 65533: return new CloseCircuitPacket(header, bytes, ref i);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
id = (ushort)bytes[7]; freq = PacketFrequency.Medium;
|
|
switch (id)
|
|
{
|
|
case 1: return new ObjectAddPacket(header, bytes, ref i);
|
|
case 2: return new MultipleObjectUpdatePacket(header, bytes, ref i);
|
|
case 3: return new RequestMultipleObjectsPacket(header, bytes, ref i);
|
|
case 4: return new ObjectPositionPacket(header, bytes, ref i);
|
|
case 5: return new RequestObjectPropertiesFamilyPacket(header, bytes, ref i);
|
|
case 6: return new CoarseLocationUpdatePacket(header, bytes, ref i);
|
|
case 7: return new CrossedRegionPacket(header, bytes, ref i);
|
|
case 8: return new ConfirmEnableSimulatorPacket(header, bytes, ref i);
|
|
case 9: return new ObjectPropertiesPacket(header, bytes, ref i);
|
|
case 10: return new ObjectPropertiesFamilyPacket(header, bytes, ref i);
|
|
case 11: return new ParcelPropertiesRequestPacket(header, bytes, ref i);
|
|
case 13: return new AttachedSoundPacket(header, bytes, ref i);
|
|
case 14: return new AttachedSoundGainChangePacket(header, bytes, ref i);
|
|
case 15: return new PreloadSoundPacket(header, bytes, ref i);
|
|
case 17: return new ViewerEffectPacket(header, bytes, ref i);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
id = (ushort)bytes[6]; freq = PacketFrequency.High;
|
|
switch (id)
|
|
{
|
|
case 1: return new StartPingCheckPacket(header, bytes, ref i);
|
|
case 2: return new CompletePingCheckPacket(header, bytes, ref i);
|
|
case 4: return new AgentUpdatePacket(header, bytes, ref i);
|
|
case 5: return new AgentAnimationPacket(header, bytes, ref i);
|
|
case 6: return new AgentRequestSitPacket(header, bytes, ref i);
|
|
case 7: return new AgentSitPacket(header, bytes, ref i);
|
|
case 8: return new RequestImagePacket(header, bytes, ref i);
|
|
case 9: return new ImageDataPacket(header, bytes, ref i);
|
|
case 10: return new ImagePacketPacket(header, bytes, ref i);
|
|
case 11: return new LayerDataPacket(header, bytes, ref i);
|
|
case 12: return new ObjectUpdatePacket(header, bytes, ref i);
|
|
case 13: return new ObjectUpdateCompressedPacket(header, bytes, ref i);
|
|
case 14: return new ObjectUpdateCachedPacket(header, bytes, ref i);
|
|
case 15: return new ImprovedTerseObjectUpdatePacket(header, bytes, ref i);
|
|
case 16: return new KillObjectPacket(header, bytes, ref i);
|
|
case 17: return new TransferPacketPacket(header, bytes, ref i);
|
|
case 18: return new SendXferPacketPacket(header, bytes, ref i);
|
|
case 19: return new ConfirmXferPacketPacket(header, bytes, ref i);
|
|
case 20: return new AvatarAnimationPacket(header, bytes, ref i);
|
|
case 21: return new AvatarSitResponsePacket(header, bytes, ref i);
|
|
case 22: return new CameraConstraintPacket(header, bytes, ref i);
|
|
case 23: return new ParcelPropertiesPacket(header, bytes, ref i);
|
|
case 25: return new ChildAgentUpdatePacket(header, bytes, ref i);
|
|
case 26: return new ChildAgentAlivePacket(header, bytes, ref i);
|
|
case 27: return new ChildAgentPositionUpdatePacket(header, bytes, ref i);
|
|
case 29: return new SoundTriggerPacket(header, bytes, ref i);
|
|
}
|
|
}
|
|
|
|
throw new MalformedDataException("Unknown packet ID "+freq+" "+id);
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TestMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TestBlock1Block : PacketBlock
|
|
{
|
|
public uint Test1;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public TestBlock1Block() { }
|
|
public TestBlock1Block(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Test1 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Test1, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TestBlock1 --");
|
|
output.Append(String.Format("Test1: {0}", Test1));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NeighborBlockBlock : PacketBlock
|
|
{
|
|
public uint Test0;
|
|
public uint Test1;
|
|
public uint Test2;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public NeighborBlockBlock() { }
|
|
public NeighborBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Test0 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Test1 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Test2 = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Test0, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Test1, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Test2, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NeighborBlock --");
|
|
output.AppendLine(String.Format("Test0: {0}", Test0));
|
|
output.AppendLine(String.Format("Test1: {0}", Test1));
|
|
output.Append(String.Format("Test2: {0}", Test2));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TestMessage; } }
|
|
public TestBlock1Block TestBlock1;
|
|
public NeighborBlockBlock[] NeighborBlock;
|
|
|
|
public TestMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 1;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
TestBlock1 = new TestBlock1Block();
|
|
NeighborBlock = new NeighborBlockBlock[4];
|
|
}
|
|
|
|
public TestMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TestBlock1.FromBytes(bytes, ref i);
|
|
if(NeighborBlock.Length < 4) {
|
|
NeighborBlock = new NeighborBlockBlock[4];
|
|
for(int j = 0; j < 4; j++) NeighborBlock[j] = new NeighborBlockBlock();
|
|
}
|
|
for (int j = 0; j < 4; j++)
|
|
{ NeighborBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public TestMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TestBlock1.FromBytes(bytes, ref i);
|
|
if(NeighborBlock.Length < 4) {
|
|
NeighborBlock = new NeighborBlockBlock[4];
|
|
for(int j = 0; j < 4; j++) NeighborBlock[j] = new NeighborBlockBlock();
|
|
}
|
|
for (int j = 0; j < 4; j++)
|
|
{ NeighborBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TestBlock1.Length;;
|
|
for (int j = 0; j < 4; j++) { length += NeighborBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TestBlock1.ToBytes(bytes, ref i);
|
|
for (int j = 0; j < 4; j++) { NeighborBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TestMessage ---" + Environment.NewLine;
|
|
output += TestBlock1.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
output += NeighborBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UseCircuitCodePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class CircuitCodeBlock : PacketBlock
|
|
{
|
|
public uint Code;
|
|
public UUID SessionID;
|
|
public UUID ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public CircuitCodeBlock() { }
|
|
public CircuitCodeBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Code = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Code, bytes, i); i += 4;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- CircuitCode --");
|
|
output.AppendLine(String.Format("Code: {0}", Code));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UseCircuitCode; } }
|
|
public CircuitCodeBlock CircuitCode;
|
|
|
|
public UseCircuitCodePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 3;
|
|
Header.Reliable = true;
|
|
CircuitCode = new CircuitCodeBlock();
|
|
}
|
|
|
|
public UseCircuitCodePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CircuitCode.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UseCircuitCodePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CircuitCode.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += CircuitCode.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
CircuitCode.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UseCircuitCode ---" + Environment.NewLine;
|
|
output += CircuitCode.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TelehubInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TelehubBlockBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
private byte[] _objectname;
|
|
public byte[] ObjectName
|
|
{
|
|
get { return _objectname; }
|
|
set
|
|
{
|
|
if (value == null) { _objectname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
|
|
}
|
|
}
|
|
public Vector3 TelehubPos;
|
|
public Quaternion TelehubRot;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 40;
|
|
if (ObjectName != null) { length += 1 + ObjectName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public TelehubBlockBlock() { }
|
|
public TelehubBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_objectname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
|
|
TelehubPos.FromBytes(bytes, i); i += 12;
|
|
TelehubRot.FromBytes(bytes, i, true); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectName.Length;
|
|
Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
|
|
Buffer.BlockCopy(TelehubPos.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(TelehubRot.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TelehubBlock --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
Helpers.FieldToString(output, ObjectName, "ObjectName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("TelehubPos: {0}", TelehubPos));
|
|
output.Append(String.Format("TelehubRot: {0}", TelehubRot));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SpawnPointBlockBlock : PacketBlock
|
|
{
|
|
public Vector3 SpawnPointPos;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public SpawnPointBlockBlock() { }
|
|
public SpawnPointBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SpawnPointPos.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SpawnPointPos.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SpawnPointBlock --");
|
|
output.Append(String.Format("SpawnPointPos: {0}", SpawnPointPos));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TelehubInfo; } }
|
|
public TelehubBlockBlock TelehubBlock;
|
|
public SpawnPointBlockBlock[] SpawnPointBlock;
|
|
|
|
public TelehubInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 10;
|
|
Header.Reliable = true;
|
|
TelehubBlock = new TelehubBlockBlock();
|
|
SpawnPointBlock = new SpawnPointBlockBlock[0];
|
|
}
|
|
|
|
public TelehubInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TelehubBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SpawnPointBlock.Length < count) {
|
|
SpawnPointBlock = new SpawnPointBlockBlock[count];
|
|
for(int j = 0; j < count; j++) SpawnPointBlock[j] = new SpawnPointBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SpawnPointBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public TelehubInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TelehubBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SpawnPointBlock.Length < count) {
|
|
SpawnPointBlock = new SpawnPointBlockBlock[count];
|
|
for(int j = 0; j < count; j++) SpawnPointBlock[j] = new SpawnPointBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SpawnPointBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TelehubBlock.Length;;
|
|
length++;
|
|
for (int j = 0; j < SpawnPointBlock.Length; j++) { length += SpawnPointBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TelehubBlock.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)SpawnPointBlock.Length;
|
|
for (int j = 0; j < SpawnPointBlock.Length; j++) { SpawnPointBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TelehubInfo ---" + Environment.NewLine;
|
|
output += TelehubBlock.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < SpawnPointBlock.Length; j++)
|
|
{
|
|
output += SpawnPointBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EconomyDataRequestPacket : Packet
|
|
{
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EconomyDataRequest; } }
|
|
|
|
public EconomyDataRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 24;
|
|
Header.Reliable = true;
|
|
}
|
|
|
|
public EconomyDataRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public EconomyDataRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EconomyDataRequest ---" + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EconomyDataPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public int ObjectCapacity;
|
|
public int ObjectCount;
|
|
public int PriceEnergyUnit;
|
|
public int PriceObjectClaim;
|
|
public int PricePublicObjectDecay;
|
|
public int PricePublicObjectDelete;
|
|
public int PriceParcelClaim;
|
|
public float PriceParcelClaimFactor;
|
|
public int PriceUpload;
|
|
public int PriceRentLight;
|
|
public int TeleportMinPrice;
|
|
public float TeleportPriceExponent;
|
|
public float EnergyEfficiency;
|
|
public float PriceObjectRent;
|
|
public float PriceObjectScaleFactor;
|
|
public int PriceParcelRent;
|
|
public int PriceGroupCreate;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 68;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectCapacity = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ObjectCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceEnergyUnit = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceObjectClaim = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PricePublicObjectDecay = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PricePublicObjectDelete = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceParcelClaim = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceParcelClaimFactor = Utils.BytesToFloat(bytes, i); i += 4;
|
|
PriceUpload = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceRentLight = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TeleportMinPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TeleportPriceExponent = Utils.BytesToFloat(bytes, i); i += 4;
|
|
EnergyEfficiency = Utils.BytesToFloat(bytes, i); i += 4;
|
|
PriceObjectRent = Utils.BytesToFloat(bytes, i); i += 4;
|
|
PriceObjectScaleFactor = Utils.BytesToFloat(bytes, i); i += 4;
|
|
PriceParcelRent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceGroupCreate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(ObjectCapacity, bytes, i); i += 4;
|
|
Utils.IntToBytes(ObjectCount, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceEnergyUnit, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceObjectClaim, bytes, i); i += 4;
|
|
Utils.IntToBytes(PricePublicObjectDecay, bytes, i); i += 4;
|
|
Utils.IntToBytes(PricePublicObjectDelete, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceParcelClaim, bytes, i); i += 4;
|
|
Utils.FloatToBytes(PriceParcelClaimFactor, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceUpload, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceRentLight, bytes, i); i += 4;
|
|
Utils.IntToBytes(TeleportMinPrice, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TeleportPriceExponent, bytes, i); i += 4;
|
|
Utils.FloatToBytes(EnergyEfficiency, bytes, i); i += 4;
|
|
Utils.FloatToBytes(PriceObjectRent, bytes, i); i += 4;
|
|
Utils.FloatToBytes(PriceObjectScaleFactor, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceParcelRent, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceGroupCreate, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("ObjectCapacity: {0}", ObjectCapacity));
|
|
output.AppendLine(String.Format("ObjectCount: {0}", ObjectCount));
|
|
output.AppendLine(String.Format("PriceEnergyUnit: {0}", PriceEnergyUnit));
|
|
output.AppendLine(String.Format("PriceObjectClaim: {0}", PriceObjectClaim));
|
|
output.AppendLine(String.Format("PricePublicObjectDecay: {0}", PricePublicObjectDecay));
|
|
output.AppendLine(String.Format("PricePublicObjectDelete: {0}", PricePublicObjectDelete));
|
|
output.AppendLine(String.Format("PriceParcelClaim: {0}", PriceParcelClaim));
|
|
output.AppendLine(String.Format("PriceParcelClaimFactor: {0}", PriceParcelClaimFactor));
|
|
output.AppendLine(String.Format("PriceUpload: {0}", PriceUpload));
|
|
output.AppendLine(String.Format("PriceRentLight: {0}", PriceRentLight));
|
|
output.AppendLine(String.Format("TeleportMinPrice: {0}", TeleportMinPrice));
|
|
output.AppendLine(String.Format("TeleportPriceExponent: {0}", TeleportPriceExponent));
|
|
output.AppendLine(String.Format("EnergyEfficiency: {0}", EnergyEfficiency));
|
|
output.AppendLine(String.Format("PriceObjectRent: {0}", PriceObjectRent));
|
|
output.AppendLine(String.Format("PriceObjectScaleFactor: {0}", PriceObjectScaleFactor));
|
|
output.AppendLine(String.Format("PriceParcelRent: {0}", PriceParcelRent));
|
|
output.Append(String.Format("PriceGroupCreate: {0}", PriceGroupCreate));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EconomyData; } }
|
|
public InfoBlock Info;
|
|
|
|
public EconomyDataPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 25;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public EconomyDataPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EconomyDataPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EconomyData ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarPickerRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarPickerRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public AvatarPickerRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 26;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public AvatarPickerRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarPickerRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarPickerRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarPickerReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID AvatarID;
|
|
private byte[] _firstname;
|
|
public byte[] FirstName
|
|
{
|
|
get { return _firstname; }
|
|
set
|
|
{
|
|
if (value == null) { _firstname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _lastname;
|
|
public byte[] LastName
|
|
{
|
|
get { return _lastname; }
|
|
set
|
|
{
|
|
if (value == null) { _lastname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (FirstName != null) { length += 1 + FirstName.Length; }
|
|
if (LastName != null) { length += 1 + LastName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AvatarID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_firstname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_lastname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FirstName.Length;
|
|
Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
|
|
if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LastName.Length;
|
|
Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("AvatarID: {0}", AvatarID));
|
|
Helpers.FieldToString(output, FirstName, "FirstName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LastName, "LastName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarPickerReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public AvatarPickerReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 28;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public AvatarPickerReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AvatarPickerReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarPickerReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PlacesQueryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
private byte[] _querytext;
|
|
public byte[] QueryText
|
|
{
|
|
get { return _querytext; }
|
|
set
|
|
{
|
|
if (value == null) { _querytext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint QueryFlags;
|
|
public sbyte Category;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 5;
|
|
if (QueryText != null) { length += 1 + QueryText.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_querytext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Category = (sbyte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)QueryText.Length;
|
|
Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
bytes[i++] = (byte)Category;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
Helpers.FieldToString(output, QueryText, "QueryText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PlacesQuery; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionDataBlock TransactionData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public PlacesQueryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 29;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionData = new TransactionDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public PlacesQueryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public PlacesQueryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PlacesQuery ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PlacesReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
public int ActualArea;
|
|
public int BillableArea;
|
|
public byte Flags;
|
|
public float GlobalX;
|
|
public float GlobalY;
|
|
public float GlobalZ;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID SnapshotID;
|
|
public float Dwell;
|
|
public int Price;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 61;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 1 + Desc.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
ActualArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
BillableArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (byte)bytes[i++];
|
|
GlobalX = Utils.BytesToFloat(bytes, i); i += 4;
|
|
GlobalY = Utils.BytesToFloat(bytes, i); i += 4;
|
|
GlobalZ = Utils.BytesToFloat(bytes, i); i += 4;
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
Dwell = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Price = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Desc.Length;
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
Utils.IntToBytes(ActualArea, bytes, i); i += 4;
|
|
Utils.IntToBytes(BillableArea, bytes, i); i += 4;
|
|
bytes[i++] = Flags;
|
|
Utils.FloatToBytes(GlobalX, bytes, i); i += 4;
|
|
Utils.FloatToBytes(GlobalY, bytes, i); i += 4;
|
|
Utils.FloatToBytes(GlobalZ, bytes, i); i += 4;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(Dwell, bytes, i); i += 4;
|
|
Utils.IntToBytes(Price, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ActualArea: {0}", ActualArea));
|
|
output.AppendLine(String.Format("BillableArea: {0}", BillableArea));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("GlobalX: {0}", GlobalX));
|
|
output.AppendLine(String.Format("GlobalY: {0}", GlobalY));
|
|
output.AppendLine(String.Format("GlobalZ: {0}", GlobalZ));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
output.AppendLine(String.Format("Dwell: {0}", Dwell));
|
|
output.Append(String.Format("Price: {0}", Price));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PlacesReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionDataBlock TransactionData;
|
|
public QueryDataBlock[] QueryData;
|
|
|
|
public PlacesReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 30;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionData = new TransactionDataBlock();
|
|
QueryData = new QueryDataBlock[0];
|
|
}
|
|
|
|
public PlacesReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryData.Length < count) {
|
|
QueryData = new QueryDataBlock[count];
|
|
for(int j = 0; j < count; j++) QueryData[j] = new QueryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public PlacesReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryData.Length < count) {
|
|
QueryData = new QueryDataBlock[count];
|
|
for(int j = 0; j < count; j++) QueryData[j] = new QueryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryData.Length; j++) { length += QueryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryData.Length;
|
|
for (int j = 0; j < QueryData.Length; j++) { QueryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PlacesReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryData.Length; j++)
|
|
{
|
|
output += QueryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirFindQueryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
private byte[] _querytext;
|
|
public byte[] QueryText
|
|
{
|
|
get { return _querytext; }
|
|
set
|
|
{
|
|
if (value == null) { _querytext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint QueryFlags;
|
|
public int QueryStart;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (QueryText != null) { length += 1 + QueryText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_querytext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)QueryText.Length;
|
|
Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
Utils.IntToBytes(QueryStart, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
Helpers.FieldToString(output, QueryText, "QueryText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
|
|
output.Append(String.Format("QueryStart: {0}", QueryStart));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirFindQuery; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public DirFindQueryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 31;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public DirFindQueryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DirFindQueryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirFindQuery ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirPlacesQueryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
private byte[] _querytext;
|
|
public byte[] QueryText
|
|
{
|
|
get { return _querytext; }
|
|
set
|
|
{
|
|
if (value == null) { _querytext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint QueryFlags;
|
|
public sbyte Category;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public int QueryStart;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 25;
|
|
if (QueryText != null) { length += 1 + QueryText.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_querytext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Category = (sbyte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)QueryText.Length;
|
|
Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
bytes[i++] = (byte)Category;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Utils.IntToBytes(QueryStart, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
Helpers.FieldToString(output, QueryText, "QueryText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("QueryStart: {0}", QueryStart));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirPlacesQuery; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public DirPlacesQueryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 33;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public DirPlacesQueryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DirPlacesQueryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirPlacesQuery ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirPlacesReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID ParcelID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool ForSale;
|
|
public bool Auction;
|
|
public float Dwell;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 22;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
ForSale = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Auction = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Dwell = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
bytes[i++] = (byte)((ForSale) ? 1 : 0);
|
|
bytes[i++] = (byte)((Auction) ? 1 : 0);
|
|
Utils.FloatToBytes(Dwell, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ForSale: {0}", ForSale));
|
|
output.AppendLine(String.Format("Auction: {0}", Auction));
|
|
output.Append(String.Format("Dwell: {0}", Dwell));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirPlacesReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock[] QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirPlacesReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 35;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock[0];
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirPlacesReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryData.Length < count) {
|
|
QueryData = new QueryDataBlock[count];
|
|
for(int j = 0; j < count; j++) QueryData[j] = new QueryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirPlacesReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryData.Length < count) {
|
|
QueryData = new QueryDataBlock[count];
|
|
for(int j = 0; j < count; j++) QueryData[j] = new QueryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryData.Length; j++) { length += QueryData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryData.Length;
|
|
for (int j = 0; j < QueryData.Length; j++) { QueryData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirPlacesReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryData.Length; j++)
|
|
{
|
|
output += QueryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirPeopleReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
private byte[] _firstname;
|
|
public byte[] FirstName
|
|
{
|
|
get { return _firstname; }
|
|
set
|
|
{
|
|
if (value == null) { _firstname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _lastname;
|
|
public byte[] LastName
|
|
{
|
|
get { return _lastname; }
|
|
set
|
|
{
|
|
if (value == null) { _lastname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _group;
|
|
public byte[] Group
|
|
{
|
|
get { return _group; }
|
|
set
|
|
{
|
|
if (value == null) { _group = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _group = new byte[value.Length]; Buffer.BlockCopy(value, 0, _group, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool Online;
|
|
public int Reputation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 21;
|
|
if (FirstName != null) { length += 1 + FirstName.Length; }
|
|
if (LastName != null) { length += 1 + LastName.Length; }
|
|
if (Group != null) { length += 1 + Group.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_firstname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_lastname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_group = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _group, 0, length); i += length;
|
|
Online = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Reputation = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FirstName.Length;
|
|
Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
|
|
if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LastName.Length;
|
|
Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
|
|
if(Group == null) { Console.WriteLine("Warning: Group is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Group.Length;
|
|
Buffer.BlockCopy(Group, 0, bytes, i, Group.Length); i += Group.Length;
|
|
bytes[i++] = (byte)((Online) ? 1 : 0);
|
|
Utils.IntToBytes(Reputation, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
Helpers.FieldToString(output, FirstName, "FirstName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LastName, "LastName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Group, "Group");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Online: {0}", Online));
|
|
output.Append(String.Format("Reputation: {0}", Reputation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirPeopleReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirPeopleReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 36;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirPeopleReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirPeopleReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirPeopleReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirEventsReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint EventID;
|
|
private byte[] _date;
|
|
public byte[] Date
|
|
{
|
|
get { return _date; }
|
|
set
|
|
{
|
|
if (value == null) { _date = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _date = new byte[value.Length]; Buffer.BlockCopy(value, 0, _date, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint UnixTime;
|
|
public uint EventFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Date != null) { length += 1 + Date.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_date = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _date, 0, length); i += length;
|
|
UnixTime = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EventFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
if(Date == null) { Console.WriteLine("Warning: Date is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Date.Length;
|
|
Buffer.BlockCopy(Date, 0, bytes, i, Date.Length); i += Date.Length;
|
|
Utils.UIntToBytes(UnixTime, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EventFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("EventID: {0}", EventID));
|
|
Helpers.FieldToString(output, Date, "Date");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("UnixTime: {0}", UnixTime));
|
|
output.Append(String.Format("EventFlags: {0}", EventFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirEventsReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirEventsReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 37;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirEventsReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirEventsReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirEventsReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirGroupsReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
private byte[] _groupname;
|
|
public byte[] GroupName
|
|
{
|
|
get { return _groupname; }
|
|
set
|
|
{
|
|
if (value == null) { _groupname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Members;
|
|
public float SearchOrder;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (GroupName != null) { length += 1 + GroupName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_groupname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
|
|
Members = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SearchOrder = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupName.Length;
|
|
Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
|
|
Utils.IntToBytes(Members, bytes, i); i += 4;
|
|
Utils.FloatToBytes(SearchOrder, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
Helpers.FieldToString(output, GroupName, "GroupName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Members: {0}", Members));
|
|
output.Append(String.Format("SearchOrder: {0}", SearchOrder));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirGroupsReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirGroupsReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 38;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirGroupsReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirGroupsReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirGroupsReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirClassifiedQueryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
private byte[] _querytext;
|
|
public byte[] QueryText
|
|
{
|
|
get { return _querytext; }
|
|
set
|
|
{
|
|
if (value == null) { _querytext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint QueryFlags;
|
|
public uint Category;
|
|
public int QueryStart;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (QueryText != null) { length += 1 + QueryText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_querytext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)QueryText.Length;
|
|
Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Category, bytes, i); i += 4;
|
|
Utils.IntToBytes(QueryStart, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
Helpers.FieldToString(output, QueryText, "QueryText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
output.Append(String.Format("QueryStart: {0}", QueryStart));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirClassifiedQuery; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public DirClassifiedQueryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 39;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public DirClassifiedQueryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DirClassifiedQueryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirClassifiedQuery ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirClassifiedReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte ClassifiedFlags;
|
|
public uint CreationDate;
|
|
public uint ExpirationDate;
|
|
public int PriceForListing;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 29;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
ClassifiedFlags = (byte)bytes[i++];
|
|
CreationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ExpirationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PriceForListing = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
bytes[i++] = ClassifiedFlags;
|
|
Utils.UIntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ExpirationDate, bytes, i); i += 4;
|
|
Utils.IntToBytes(PriceForListing, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ClassifiedFlags: {0}", ClassifiedFlags));
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.AppendLine(String.Format("ExpirationDate: {0}", ExpirationDate));
|
|
output.Append(String.Format("PriceForListing: {0}", PriceForListing));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirClassifiedReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirClassifiedReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 41;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirClassifiedReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirClassifiedReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirClassifiedReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarClassifiedReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID TargetID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("TargetID: {0}", TargetID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarClassifiedReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public AvatarClassifiedReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 42;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public AvatarClassifiedReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AvatarClassifiedReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarClassifiedReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ClassifiedInfoRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ClassifiedInfoRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ClassifiedInfoRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 43;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ClassifiedInfoRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ClassifiedInfoRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ClassifiedInfoRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ClassifiedInfoReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
public UUID CreatorID;
|
|
public uint CreationDate;
|
|
public uint ExpirationDate;
|
|
public uint Category;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID ParcelID;
|
|
public uint ParentEstate;
|
|
public UUID SnapshotID;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public Vector3d PosGlobal;
|
|
private byte[] _parcelname;
|
|
public byte[] ParcelName
|
|
{
|
|
get { return _parcelname; }
|
|
set
|
|
{
|
|
if (value == null) { _parcelname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _parcelname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parcelname, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte ClassifiedFlags;
|
|
public int PriceForListing;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 109;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 2 + Desc.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
if (ParcelName != null) { length += 1 + ParcelName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
CreationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ExpirationDate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
ParentEstate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
PosGlobal.FromBytes(bytes, i); i += 24;
|
|
length = (ushort)bytes[i++];
|
|
_parcelname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _parcelname, 0, length); i += length;
|
|
ClassifiedFlags = (byte)bytes[i++];
|
|
PriceForListing = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ExpirationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Category, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Desc.Length % 256);
|
|
bytes[i++] = (byte)((Desc.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(ParentEstate, bytes, i); i += 4;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
|
|
if(ParcelName == null) { Console.WriteLine("Warning: ParcelName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ParcelName.Length;
|
|
Buffer.BlockCopy(ParcelName, 0, bytes, i, ParcelName.Length); i += ParcelName.Length;
|
|
bytes[i++] = ClassifiedFlags;
|
|
Utils.IntToBytes(PriceForListing, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.AppendLine(String.Format("ExpirationDate: {0}", ExpirationDate));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
output.AppendLine(String.Format("ParentEstate: {0}", ParentEstate));
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
|
|
Helpers.FieldToString(output, ParcelName, "ParcelName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ClassifiedFlags: {0}", ClassifiedFlags));
|
|
output.Append(String.Format("PriceForListing: {0}", PriceForListing));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ClassifiedInfoReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ClassifiedInfoReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 44;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ClassifiedInfoReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ClassifiedInfoReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ClassifiedInfoReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ClassifiedInfoUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
public uint Category;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID ParcelID;
|
|
public uint ParentEstate;
|
|
public UUID SnapshotID;
|
|
public Vector3d PosGlobal;
|
|
public byte ClassifiedFlags;
|
|
public int PriceForListing;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 85;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 2 + Desc.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
ParentEstate = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
PosGlobal.FromBytes(bytes, i); i += 24;
|
|
ClassifiedFlags = (byte)bytes[i++];
|
|
PriceForListing = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Category, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Desc.Length % 256);
|
|
bytes[i++] = (byte)((Desc.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(ParentEstate, bytes, i); i += 4;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
|
|
bytes[i++] = ClassifiedFlags;
|
|
Utils.IntToBytes(PriceForListing, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
output.AppendLine(String.Format("ParentEstate: {0}", ParentEstate));
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
|
|
output.AppendLine(String.Format("ClassifiedFlags: {0}", ClassifiedFlags));
|
|
output.Append(String.Format("PriceForListing: {0}", PriceForListing));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ClassifiedInfoUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ClassifiedInfoUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 45;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ClassifiedInfoUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ClassifiedInfoUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ClassifiedInfoUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ClassifiedDeletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ClassifiedDelete; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ClassifiedDeletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 46;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ClassifiedDeletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ClassifiedDeletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ClassifiedDelete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ClassifiedGodDeletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ClassifiedID;
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ClassifiedID.FromBytes(bytes, i); i += 16;
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ClassifiedID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ClassifiedID: {0}", ClassifiedID));
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ClassifiedGodDelete; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ClassifiedGodDeletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 47;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ClassifiedGodDeletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ClassifiedGodDeletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ClassifiedGodDelete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirLandQueryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
public uint QueryFlags;
|
|
public uint SearchType;
|
|
public int Price;
|
|
public int Area;
|
|
public int QueryStart;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SearchType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Price = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Area = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(SearchType, bytes, i); i += 4;
|
|
Utils.IntToBytes(Price, bytes, i); i += 4;
|
|
Utils.IntToBytes(Area, bytes, i); i += 4;
|
|
Utils.IntToBytes(QueryStart, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
|
|
output.AppendLine(String.Format("SearchType: {0}", SearchType));
|
|
output.AppendLine(String.Format("Price: {0}", Price));
|
|
output.AppendLine(String.Format("Area: {0}", Area));
|
|
output.Append(String.Format("QueryStart: {0}", QueryStart));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirLandQuery; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public DirLandQueryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 48;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public DirLandQueryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DirLandQueryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirLandQuery ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirLandReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID ParcelID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool Auction;
|
|
public bool ForSale;
|
|
public int SalePrice;
|
|
public int ActualArea;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 26;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
Auction = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ForSale = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ActualArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
bytes[i++] = (byte)((Auction) ? 1 : 0);
|
|
bytes[i++] = (byte)((ForSale) ? 1 : 0);
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
Utils.IntToBytes(ActualArea, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Auction: {0}", Auction));
|
|
output.AppendLine(String.Format("ForSale: {0}", ForSale));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
output.Append(String.Format("ActualArea: {0}", ActualArea));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirLandReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirLandReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 50;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirLandReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirLandReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirLandReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirPopularQueryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
public uint QueryFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
output.Append(String.Format("QueryFlags: {0}", QueryFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirPopularQuery; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public DirPopularQueryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 51;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public DirPopularQueryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DirPopularQueryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirPopularQuery ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DirPopularReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryRepliesBlock : PacketBlock
|
|
{
|
|
public UUID ParcelID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public float Dwell;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 20;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryRepliesBlock() { }
|
|
public QueryRepliesBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
Dwell = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
Utils.FloatToBytes(Dwell, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryReplies --");
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Dwell: {0}", Dwell));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DirPopularReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public QueryDataBlock QueryData;
|
|
public QueryRepliesBlock[] QueryReplies;
|
|
|
|
public DirPopularReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 53;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
QueryReplies = new QueryRepliesBlock[0];
|
|
}
|
|
|
|
public DirPopularReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DirPopularReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(QueryReplies.Length < count) {
|
|
QueryReplies = new QueryRepliesBlock[count];
|
|
for(int j = 0; j < count; j++) QueryReplies[j] = new QueryRepliesBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ QueryReplies[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += QueryData.Length;;
|
|
length++;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)QueryReplies.Length;
|
|
for (int j = 0; j < QueryReplies.Length; j++) { QueryReplies[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DirPopularReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < QueryReplies.Length; j++)
|
|
{
|
|
output += QueryReplies[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelInfoRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ParcelID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("ParcelID: {0}", ParcelID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelInfoRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelInfoRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 54;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelInfoRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelInfoRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelInfoRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelInfoReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ParcelID;
|
|
public UUID OwnerID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
public int ActualArea;
|
|
public int BillableArea;
|
|
public byte Flags;
|
|
public float GlobalX;
|
|
public float GlobalY;
|
|
public float GlobalZ;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID SnapshotID;
|
|
public float Dwell;
|
|
public int SalePrice;
|
|
public int AuctionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 81;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 1 + Desc.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
ActualArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
BillableArea = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (byte)bytes[i++];
|
|
GlobalX = Utils.BytesToFloat(bytes, i); i += 4;
|
|
GlobalY = Utils.BytesToFloat(bytes, i); i += 4;
|
|
GlobalZ = Utils.BytesToFloat(bytes, i); i += 4;
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
Dwell = Utils.BytesToFloat(bytes, i); i += 4;
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AuctionID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Desc.Length;
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
Utils.IntToBytes(ActualArea, bytes, i); i += 4;
|
|
Utils.IntToBytes(BillableArea, bytes, i); i += 4;
|
|
bytes[i++] = Flags;
|
|
Utils.FloatToBytes(GlobalX, bytes, i); i += 4;
|
|
Utils.FloatToBytes(GlobalY, bytes, i); i += 4;
|
|
Utils.FloatToBytes(GlobalZ, bytes, i); i += 4;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(Dwell, bytes, i); i += 4;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
Utils.IntToBytes(AuctionID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ActualArea: {0}", ActualArea));
|
|
output.AppendLine(String.Format("BillableArea: {0}", BillableArea));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("GlobalX: {0}", GlobalX));
|
|
output.AppendLine(String.Format("GlobalY: {0}", GlobalY));
|
|
output.AppendLine(String.Format("GlobalZ: {0}", GlobalZ));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
output.AppendLine(String.Format("Dwell: {0}", Dwell));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
output.Append(String.Format("AuctionID: {0}", AuctionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelInfoReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelInfoReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 55;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelInfoReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelInfoReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelInfoReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelObjectOwnersRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelObjectOwnersRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelObjectOwnersRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 56;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelObjectOwnersRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelObjectOwnersRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelObjectOwnersRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelObjectOwnersReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
public bool IsGroupOwned;
|
|
public int Count;
|
|
public bool OnlineStatus;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 22;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Count = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OnlineStatus = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
|
|
Utils.IntToBytes(Count, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((OnlineStatus) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
|
|
output.AppendLine(String.Format("Count: {0}", Count));
|
|
output.Append(String.Format("OnlineStatus: {0}", OnlineStatus));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelObjectOwnersReply; } }
|
|
public DataBlock[] Data;
|
|
|
|
public ParcelObjectOwnersReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 57;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public ParcelObjectOwnersReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelObjectOwnersReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelObjectOwnersReply ---" + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupNoticesListRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupNoticesListRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public GroupNoticesListRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 58;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public GroupNoticesListRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupNoticesListRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupNoticesListRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupNoticesListReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID NoticeID;
|
|
public uint Timestamp;
|
|
private byte[] _fromname;
|
|
public byte[] FromName
|
|
{
|
|
get { return _fromname; }
|
|
set
|
|
{
|
|
if (value == null) { _fromname = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _fromname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _fromname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _subject;
|
|
public byte[] Subject
|
|
{
|
|
get { return _subject; }
|
|
set
|
|
{
|
|
if (value == null) { _subject = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _subject = new byte[value.Length]; Buffer.BlockCopy(value, 0, _subject, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool HasAttachment;
|
|
public byte AssetType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 22;
|
|
if (FromName != null) { length += 2 + FromName.Length; }
|
|
if (Subject != null) { length += 2 + Subject.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
NoticeID.FromBytes(bytes, i); i += 16;
|
|
Timestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_fromname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _fromname, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_subject = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _subject, 0, length); i += length;
|
|
HasAttachment = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AssetType = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(NoticeID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Timestamp, bytes, i); i += 4;
|
|
if(FromName == null) { Console.WriteLine("Warning: FromName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(FromName.Length % 256);
|
|
bytes[i++] = (byte)((FromName.Length >> 8) % 256);
|
|
Buffer.BlockCopy(FromName, 0, bytes, i, FromName.Length); i += FromName.Length;
|
|
if(Subject == null) { Console.WriteLine("Warning: Subject is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Subject.Length % 256);
|
|
bytes[i++] = (byte)((Subject.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Subject, 0, bytes, i, Subject.Length); i += Subject.Length;
|
|
bytes[i++] = (byte)((HasAttachment) ? 1 : 0);
|
|
bytes[i++] = AssetType;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("NoticeID: {0}", NoticeID));
|
|
output.AppendLine(String.Format("Timestamp: {0}", Timestamp));
|
|
Helpers.FieldToString(output, FromName, "FromName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Subject, "Subject");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("HasAttachment: {0}", HasAttachment));
|
|
output.Append(String.Format("AssetType: {0}", AssetType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupNoticesListReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public GroupNoticesListReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 59;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public GroupNoticesListReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupNoticesListReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupNoticesListReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupNoticeRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupNoticeID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupNoticeID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupNoticeID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("GroupNoticeID: {0}", GroupNoticeID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupNoticeRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public GroupNoticeRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 60;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public GroupNoticeRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupNoticeRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupNoticeRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID RegionID;
|
|
public Vector3 Position;
|
|
public Vector3 LookAt;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 40;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionID.FromBytes(bytes, i); i += 16;
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
LookAt.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("RegionID: {0}", RegionID));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.Append(String.Format("LookAt: {0}", LookAt));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public InfoBlock Info;
|
|
|
|
public TeleportRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 62;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportLocationRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public Vector3 Position;
|
|
public Vector3 LookAt;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
LookAt.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.Append(String.Format("LookAt: {0}", LookAt));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportLocationRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public InfoBlock Info;
|
|
|
|
public TeleportLocationRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 63;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportLocationRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportLocationRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportLocationRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportLocalPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public uint LocationID;
|
|
public Vector3 Position;
|
|
public Vector3 LookAt;
|
|
public uint TeleportFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
LocationID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
LookAt.FromBytes(bytes, i); i += 12;
|
|
TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(LocationID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.UIntToBytes(TeleportFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("LocationID: {0}", LocationID));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("LookAt: {0}", LookAt));
|
|
output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportLocal; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportLocalPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 64;
|
|
Header.Reliable = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportLocalPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportLocalPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportLocal ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportLandmarkRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID LandmarkID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
LandmarkID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(LandmarkID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("LandmarkID: {0}", LandmarkID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportLandmarkRequest; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportLandmarkRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 65;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportLandmarkRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportLandmarkRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportLandmarkRequest ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportProgressPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public uint TeleportFlags;
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Message != null) { length += 1 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(TeleportFlags, bytes, i); i += 4;
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Message.Length;
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("TeleportFlags: {0}", TeleportFlags));
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportProgress; } }
|
|
public AgentDataBlock AgentData;
|
|
public InfoBlock Info;
|
|
|
|
public TeleportProgressPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 66;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportProgressPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportProgressPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportProgress ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportFinishPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public uint LocationID;
|
|
public uint SimIP;
|
|
public ushort SimPort;
|
|
public ulong RegionHandle;
|
|
private byte[] _seedcapability;
|
|
public byte[] SeedCapability
|
|
{
|
|
get { return _seedcapability; }
|
|
set
|
|
{
|
|
if (value == null) { _seedcapability = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _seedcapability = new byte[value.Length]; Buffer.BlockCopy(value, 0, _seedcapability, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte SimAccess;
|
|
public uint TeleportFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 39;
|
|
if (SeedCapability != null) { length += 2 + SeedCapability.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
LocationID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SimIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SimPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_seedcapability = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _seedcapability, 0, length); i += length;
|
|
SimAccess = (byte)bytes[i++];
|
|
TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(LocationID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(SimIP, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((SimPort >> 8) % 256);
|
|
bytes[i++] = (byte)(SimPort % 256);
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
if(SeedCapability == null) { Console.WriteLine("Warning: SeedCapability is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(SeedCapability.Length % 256);
|
|
bytes[i++] = (byte)((SeedCapability.Length >> 8) % 256);
|
|
Buffer.BlockCopy(SeedCapability, 0, bytes, i, SeedCapability.Length); i += SeedCapability.Length;
|
|
bytes[i++] = SimAccess;
|
|
Utils.UIntToBytes(TeleportFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("LocationID: {0}", LocationID));
|
|
output.AppendLine(String.Format("SimIP: {0}", SimIP));
|
|
output.AppendLine(String.Format("SimPort: {0}", SimPort));
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
Helpers.FieldToString(output, SeedCapability, "SeedCapability");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SimAccess: {0}", SimAccess));
|
|
output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportFinish; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportFinishPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 69;
|
|
Header.Reliable = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportFinishPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportFinishPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportFinish ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class StartLurePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public byte LureType;
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 1;
|
|
if (Message != null) { length += 1 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
LureType = (byte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = LureType;
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Message.Length;
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("LureType: {0}", LureType));
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TargetDataBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TargetDataBlock() { }
|
|
public TargetDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TargetData --");
|
|
output.Append(String.Format("TargetID: {0}", TargetID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.StartLure; } }
|
|
public AgentDataBlock AgentData;
|
|
public InfoBlock Info;
|
|
public TargetDataBlock[] TargetData;
|
|
|
|
public StartLurePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 70;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Info = new InfoBlock();
|
|
TargetData = new TargetDataBlock[0];
|
|
}
|
|
|
|
public StartLurePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(TargetData.Length < count) {
|
|
TargetData = new TargetDataBlock[count];
|
|
for(int j = 0; j < count; j++) TargetData[j] = new TargetDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ TargetData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public StartLurePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(TargetData.Length < count) {
|
|
TargetData = new TargetDataBlock[count];
|
|
for(int j = 0; j < count; j++) TargetData[j] = new TargetDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ TargetData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Info.Length;;
|
|
length++;
|
|
for (int j = 0; j < TargetData.Length; j++) { length += TargetData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)TargetData.Length;
|
|
for (int j = 0; j < TargetData.Length; j++) { TargetData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- StartLure ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < TargetData.Length; j++)
|
|
{
|
|
output += TargetData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportLureRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID LureID;
|
|
public uint TeleportFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 52;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
LureID.FromBytes(bytes, i); i += 16;
|
|
TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(LureID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(TeleportFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("LureID: {0}", LureID));
|
|
output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportLureRequest; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportLureRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 71;
|
|
Header.Reliable = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportLureRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportLureRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportLureRequest ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportCancelPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportCancel; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportCancelPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 72;
|
|
Header.Reliable = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportCancelPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportCancelPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportCancel ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportStartPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public uint TeleportFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TeleportFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(TeleportFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.Append(String.Format("TeleportFlags: {0}", TeleportFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportStart; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportStartPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 73;
|
|
Header.Reliable = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportStartPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportStartPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportStart ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TeleportFailedPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
private byte[] _reason;
|
|
public byte[] Reason
|
|
{
|
|
get { return _reason; }
|
|
set
|
|
{
|
|
if (value == null) { _reason = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _reason = new byte[value.Length]; Buffer.BlockCopy(value, 0, _reason, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Reason != null) { length += 1 + Reason.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_reason = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _reason, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Reason == null) { Console.WriteLine("Warning: Reason is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Reason.Length;
|
|
Buffer.BlockCopy(Reason, 0, bytes, i, Reason.Length); i += Reason.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
Helpers.FieldToString(output, Reason, "Reason");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TeleportFailed; } }
|
|
public InfoBlock Info;
|
|
|
|
public TeleportFailedPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 74;
|
|
Header.Reliable = true;
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public TeleportFailedPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TeleportFailedPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TeleportFailed ---" + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UndoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.Undo; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public UndoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 75;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public UndoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UndoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- Undo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RedoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.Redo; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public RedoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 76;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public RedoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RedoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- Redo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UndoLandPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UndoLand; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public UndoLandPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 77;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public UndoLandPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UndoLandPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UndoLand ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentPausePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint SerialNum;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(SerialNum, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("SerialNum: {0}", SerialNum));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentPause; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentPausePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 78;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentPausePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentPausePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentPause ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentResumePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint SerialNum;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(SerialNum, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("SerialNum: {0}", SerialNum));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentResume; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentResumePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 79;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentResumePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentResumePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentResume ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChatFromViewerPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChatDataBlock : PacketBlock
|
|
{
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte Type;
|
|
public int Channel;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 5;
|
|
if (Message != null) { length += 2 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ChatDataBlock() { }
|
|
public ChatDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
Type = (byte)bytes[i++];
|
|
Channel = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Message.Length % 256);
|
|
bytes[i++] = (byte)((Message.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
bytes[i++] = Type;
|
|
Utils.IntToBytes(Channel, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ChatData --");
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.Append(String.Format("Channel: {0}", Channel));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChatFromViewer; } }
|
|
public AgentDataBlock AgentData;
|
|
public ChatDataBlock ChatData;
|
|
|
|
public ChatFromViewerPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 80;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ChatData = new ChatDataBlock();
|
|
}
|
|
|
|
public ChatFromViewerPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ChatData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ChatFromViewerPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ChatData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ChatData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ChatData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChatFromViewer ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ChatData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentThrottlePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint CircuitCode;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CircuitCode, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("CircuitCode: {0}", CircuitCode));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ThrottleBlock : PacketBlock
|
|
{
|
|
public uint GenCounter;
|
|
private byte[] _throttles;
|
|
public byte[] Throttles
|
|
{
|
|
get { return _throttles; }
|
|
set
|
|
{
|
|
if (value == null) { _throttles = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _throttles = new byte[value.Length]; Buffer.BlockCopy(value, 0, _throttles, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Throttles != null) { length += 1 + Throttles.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ThrottleBlock() { }
|
|
public ThrottleBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GenCounter = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_throttles = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _throttles, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(GenCounter, bytes, i); i += 4;
|
|
if(Throttles == null) { Console.WriteLine("Warning: Throttles is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Throttles.Length;
|
|
Buffer.BlockCopy(Throttles, 0, bytes, i, Throttles.Length); i += Throttles.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Throttle --");
|
|
output.AppendLine(String.Format("GenCounter: {0}", GenCounter));
|
|
Helpers.FieldToString(output, Throttles, "Throttles");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentThrottle; } }
|
|
public AgentDataBlock AgentData;
|
|
public ThrottleBlock Throttle;
|
|
|
|
public AgentThrottlePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 81;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Throttle = new ThrottleBlock();
|
|
}
|
|
|
|
public AgentThrottlePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Throttle.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentThrottlePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Throttle.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Throttle.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Throttle.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentThrottle ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Throttle.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentFOVPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint CircuitCode;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CircuitCode, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("CircuitCode: {0}", CircuitCode));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FOVBlockBlock : PacketBlock
|
|
{
|
|
public uint GenCounter;
|
|
public float VerticalAngle;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public FOVBlockBlock() { }
|
|
public FOVBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GenCounter = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
VerticalAngle = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(GenCounter, bytes, i); i += 4;
|
|
Utils.FloatToBytes(VerticalAngle, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FOVBlock --");
|
|
output.AppendLine(String.Format("GenCounter: {0}", GenCounter));
|
|
output.Append(String.Format("VerticalAngle: {0}", VerticalAngle));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentFOV; } }
|
|
public AgentDataBlock AgentData;
|
|
public FOVBlockBlock FOVBlock;
|
|
|
|
public AgentFOVPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 82;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FOVBlock = new FOVBlockBlock();
|
|
}
|
|
|
|
public AgentFOVPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FOVBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentFOVPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FOVBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += FOVBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
FOVBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentFOV ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += FOVBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentHeightWidthPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint CircuitCode;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CircuitCode, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("CircuitCode: {0}", CircuitCode));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HeightWidthBlockBlock : PacketBlock
|
|
{
|
|
public uint GenCounter;
|
|
public ushort Height;
|
|
public ushort Width;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public HeightWidthBlockBlock() { }
|
|
public HeightWidthBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GenCounter = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Height = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
Width = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(GenCounter, bytes, i); i += 4;
|
|
bytes[i++] = (byte)(Height % 256);
|
|
bytes[i++] = (byte)((Height >> 8) % 256);
|
|
bytes[i++] = (byte)(Width % 256);
|
|
bytes[i++] = (byte)((Width >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HeightWidthBlock --");
|
|
output.AppendLine(String.Format("GenCounter: {0}", GenCounter));
|
|
output.AppendLine(String.Format("Height: {0}", Height));
|
|
output.Append(String.Format("Width: {0}", Width));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentHeightWidth; } }
|
|
public AgentDataBlock AgentData;
|
|
public HeightWidthBlockBlock HeightWidthBlock;
|
|
|
|
public AgentHeightWidthPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 83;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
HeightWidthBlock = new HeightWidthBlockBlock();
|
|
}
|
|
|
|
public AgentHeightWidthPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeightWidthBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentHeightWidthPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeightWidthBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += HeightWidthBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
HeightWidthBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentHeightWidth ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += HeightWidthBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentSetAppearancePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint SerialNum;
|
|
public Vector3 Size;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Size.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(SerialNum, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Size.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("SerialNum: {0}", SerialNum));
|
|
output.Append(String.Format("Size: {0}", Size));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class WearableDataBlock : PacketBlock
|
|
{
|
|
public UUID CacheID;
|
|
public byte TextureIndex;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public WearableDataBlock() { }
|
|
public WearableDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
CacheID.FromBytes(bytes, i); i += 16;
|
|
TextureIndex = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(CacheID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = TextureIndex;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- WearableData --");
|
|
output.AppendLine(String.Format("CacheID: {0}", CacheID));
|
|
output.Append(String.Format("TextureIndex: {0}", TextureIndex));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
private byte[] _textureentry;
|
|
public byte[] TextureEntry
|
|
{
|
|
get { return _textureentry; }
|
|
set
|
|
{
|
|
if (value == null) { _textureentry = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_textureentry = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(TextureEntry.Length % 256);
|
|
bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
|
|
Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
Helpers.FieldToString(output, TextureEntry, "TextureEntry");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class VisualParamBlock : PacketBlock
|
|
{
|
|
public byte ParamValue;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public VisualParamBlock() { }
|
|
public VisualParamBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ParamValue = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = ParamValue;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- VisualParam --");
|
|
output.Append(String.Format("ParamValue: {0}", ParamValue));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentSetAppearance; } }
|
|
public AgentDataBlock AgentData;
|
|
public WearableDataBlock[] WearableData;
|
|
public ObjectDataBlock ObjectData;
|
|
public VisualParamBlock[] VisualParam;
|
|
|
|
public AgentSetAppearancePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 84;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
WearableData = new WearableDataBlock[0];
|
|
ObjectData = new ObjectDataBlock();
|
|
VisualParam = new VisualParamBlock[0];
|
|
}
|
|
|
|
public AgentSetAppearancePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
count = (int)bytes[i++];
|
|
if(VisualParam.Length < count) {
|
|
VisualParam = new VisualParamBlock[count];
|
|
for(int j = 0; j < count; j++) VisualParam[j] = new VisualParamBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VisualParam[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentSetAppearancePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
count = (int)bytes[i++];
|
|
if(VisualParam.Length < count) {
|
|
VisualParam = new VisualParamBlock[count];
|
|
for(int j = 0; j < count; j++) VisualParam[j] = new VisualParamBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VisualParam[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)WearableData.Length;
|
|
for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)VisualParam.Length;
|
|
for (int j = 0; j < VisualParam.Length; j++) { VisualParam[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentSetAppearance ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < WearableData.Length; j++)
|
|
{
|
|
output += WearableData[j].ToString() + Environment.NewLine;
|
|
}
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < VisualParam.Length; j++)
|
|
{
|
|
output += VisualParam[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentQuitCopyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FuseBlockBlock : PacketBlock
|
|
{
|
|
public uint ViewerCircuitCode;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public FuseBlockBlock() { }
|
|
public FuseBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ViewerCircuitCode, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FuseBlock --");
|
|
output.Append(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentQuitCopy; } }
|
|
public AgentDataBlock AgentData;
|
|
public FuseBlockBlock FuseBlock;
|
|
|
|
public AgentQuitCopyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 85;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FuseBlock = new FuseBlockBlock();
|
|
}
|
|
|
|
public AgentQuitCopyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FuseBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentQuitCopyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FuseBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += FuseBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
FuseBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentQuitCopy ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += FuseBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImageNotInDatabasePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ImageIDBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ImageIDBlock() { }
|
|
public ImageIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ImageID --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ImageNotInDatabase; } }
|
|
public ImageIDBlock ImageID;
|
|
|
|
public ImageNotInDatabasePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 86;
|
|
Header.Reliable = true;
|
|
ImageID = new ImageIDBlock();
|
|
}
|
|
|
|
public ImageNotInDatabasePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ImageID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ImageNotInDatabasePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ImageID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ImageID.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ImageID.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ImageNotInDatabase ---" + Environment.NewLine;
|
|
output += ImageID.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RebakeAvatarTexturesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TextureDataBlock : PacketBlock
|
|
{
|
|
public UUID TextureID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TextureDataBlock() { }
|
|
public TextureDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TextureID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TextureID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TextureData --");
|
|
output.Append(String.Format("TextureID: {0}", TextureID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RebakeAvatarTextures; } }
|
|
public TextureDataBlock TextureData;
|
|
|
|
public RebakeAvatarTexturesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 87;
|
|
Header.Reliable = true;
|
|
TextureData = new TextureDataBlock();
|
|
}
|
|
|
|
public RebakeAvatarTexturesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TextureData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RebakeAvatarTexturesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TextureData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TextureData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TextureData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RebakeAvatarTextures ---" + Environment.NewLine;
|
|
output += TextureData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SetAlwaysRunPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public bool AlwaysRun;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
AlwaysRun = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((AlwaysRun) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("AlwaysRun: {0}", AlwaysRun));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SetAlwaysRun; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public SetAlwaysRunPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 88;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public SetAlwaysRunPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SetAlwaysRunPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SetAlwaysRun ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDeletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public bool Force;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Force = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Force) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("Force: {0}", Force));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDelete; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDeletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 89;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDeletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDeletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDelete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDuplicatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SharedDataBlock : PacketBlock
|
|
{
|
|
public Vector3 Offset;
|
|
public uint DuplicateFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public SharedDataBlock() { }
|
|
public SharedDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Offset.FromBytes(bytes, i); i += 12;
|
|
DuplicateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Offset.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.UIntToBytes(DuplicateFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SharedData --");
|
|
output.AppendLine(String.Format("Offset: {0}", Offset));
|
|
output.Append(String.Format("DuplicateFlags: {0}", DuplicateFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDuplicate; } }
|
|
public AgentDataBlock AgentData;
|
|
public SharedDataBlock SharedData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDuplicatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 90;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
SharedData = new SharedDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDuplicatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
SharedData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDuplicatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
SharedData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += SharedData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
SharedData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDuplicate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += SharedData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDuplicateOnRayPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
public Vector3 RayStart;
|
|
public Vector3 RayEnd;
|
|
public bool BypassRaycast;
|
|
public bool RayEndIsIntersection;
|
|
public bool CopyCenters;
|
|
public bool CopyRotates;
|
|
public UUID RayTargetID;
|
|
public uint DuplicateFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 96;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RayStart.FromBytes(bytes, i); i += 12;
|
|
RayEnd.FromBytes(bytes, i); i += 12;
|
|
BypassRaycast = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RayEndIsIntersection = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
CopyCenters = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
CopyRotates = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RayTargetID.FromBytes(bytes, i); i += 16;
|
|
DuplicateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = (byte)((BypassRaycast) ? 1 : 0);
|
|
bytes[i++] = (byte)((RayEndIsIntersection) ? 1 : 0);
|
|
bytes[i++] = (byte)((CopyCenters) ? 1 : 0);
|
|
bytes[i++] = (byte)((CopyRotates) ? 1 : 0);
|
|
Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(DuplicateFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("RayStart: {0}", RayStart));
|
|
output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
|
|
output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
|
|
output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
|
|
output.AppendLine(String.Format("CopyCenters: {0}", CopyCenters));
|
|
output.AppendLine(String.Format("CopyRotates: {0}", CopyRotates));
|
|
output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
|
|
output.Append(String.Format("DuplicateFlags: {0}", DuplicateFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDuplicateOnRay; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDuplicateOnRayPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 91;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDuplicateOnRayPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDuplicateOnRayPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDuplicateOnRay ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectScalePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public Vector3 Scale;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Scale.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Scale.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("Scale: {0}", Scale));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectScale; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectScalePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 92;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectScalePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectScalePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectScale ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectRotationPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public Quaternion Rotation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Rotation.FromBytes(bytes, i, true); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("Rotation: {0}", Rotation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectRotation; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectRotationPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 93;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectRotationPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectRotationPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectRotation ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectFlagUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint ObjectLocalID;
|
|
public bool UsePhysics;
|
|
public bool IsTemporary;
|
|
public bool IsPhantom;
|
|
public bool CastsShadows;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 40;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
UsePhysics = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
IsTemporary = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
IsPhantom = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
CastsShadows = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((UsePhysics) ? 1 : 0);
|
|
bytes[i++] = (byte)((IsTemporary) ? 1 : 0);
|
|
bytes[i++] = (byte)((IsPhantom) ? 1 : 0);
|
|
bytes[i++] = (byte)((CastsShadows) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.AppendLine(String.Format("UsePhysics: {0}", UsePhysics));
|
|
output.AppendLine(String.Format("IsTemporary: {0}", IsTemporary));
|
|
output.AppendLine(String.Format("IsPhantom: {0}", IsPhantom));
|
|
output.Append(String.Format("CastsShadows: {0}", CastsShadows));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectFlagUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ObjectFlagUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 94;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ObjectFlagUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ObjectFlagUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectFlagUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectClickActionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public byte ClickAction;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ClickAction = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = ClickAction;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("ClickAction: {0}", ClickAction));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectClickAction; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectClickActionPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 95;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectClickActionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectClickActionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectClickAction ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectImagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
private byte[] _mediaurl;
|
|
public byte[] MediaURL
|
|
{
|
|
get { return _mediaurl; }
|
|
set
|
|
{
|
|
if (value == null) { _mediaurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _textureentry;
|
|
public byte[] TextureEntry
|
|
{
|
|
get { return _textureentry; }
|
|
set
|
|
{
|
|
if (value == null) { _textureentry = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (MediaURL != null) { length += 1 + MediaURL.Length; }
|
|
if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_mediaurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_textureentry = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaURL.Length;
|
|
Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
|
|
if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(TextureEntry.Length % 256);
|
|
bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
|
|
Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
Helpers.FieldToString(output, MediaURL, "MediaURL");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TextureEntry, "TextureEntry");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectImage; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectImagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 96;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectImagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectImagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectImage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectMaterialPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public byte Material;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Material = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = Material;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("Material: {0}", Material));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectMaterial; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectMaterialPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 97;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectMaterialPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectMaterialPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectMaterial ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectShapePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public byte PathCurve;
|
|
public byte ProfileCurve;
|
|
public ushort PathBegin;
|
|
public ushort PathEnd;
|
|
public byte PathScaleX;
|
|
public byte PathScaleY;
|
|
public byte PathShearX;
|
|
public byte PathShearY;
|
|
public sbyte PathTwist;
|
|
public sbyte PathTwistBegin;
|
|
public sbyte PathRadiusOffset;
|
|
public sbyte PathTaperX;
|
|
public sbyte PathTaperY;
|
|
public byte PathRevolutions;
|
|
public sbyte PathSkew;
|
|
public ushort ProfileBegin;
|
|
public ushort ProfileEnd;
|
|
public ushort ProfileHollow;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 27;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PathCurve = (byte)bytes[i++];
|
|
ProfileCurve = (byte)bytes[i++];
|
|
PathBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
PathEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
PathScaleX = (byte)bytes[i++];
|
|
PathScaleY = (byte)bytes[i++];
|
|
PathShearX = (byte)bytes[i++];
|
|
PathShearY = (byte)bytes[i++];
|
|
PathTwist = (sbyte)bytes[i++];
|
|
PathTwistBegin = (sbyte)bytes[i++];
|
|
PathRadiusOffset = (sbyte)bytes[i++];
|
|
PathTaperX = (sbyte)bytes[i++];
|
|
PathTaperY = (sbyte)bytes[i++];
|
|
PathRevolutions = (byte)bytes[i++];
|
|
PathSkew = (sbyte)bytes[i++];
|
|
ProfileBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ProfileEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ProfileHollow = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = PathCurve;
|
|
bytes[i++] = ProfileCurve;
|
|
bytes[i++] = (byte)(PathBegin % 256);
|
|
bytes[i++] = (byte)((PathBegin >> 8) % 256);
|
|
bytes[i++] = (byte)(PathEnd % 256);
|
|
bytes[i++] = (byte)((PathEnd >> 8) % 256);
|
|
bytes[i++] = PathScaleX;
|
|
bytes[i++] = PathScaleY;
|
|
bytes[i++] = PathShearX;
|
|
bytes[i++] = PathShearY;
|
|
bytes[i++] = (byte)PathTwist;
|
|
bytes[i++] = (byte)PathTwistBegin;
|
|
bytes[i++] = (byte)PathRadiusOffset;
|
|
bytes[i++] = (byte)PathTaperX;
|
|
bytes[i++] = (byte)PathTaperY;
|
|
bytes[i++] = PathRevolutions;
|
|
bytes[i++] = (byte)PathSkew;
|
|
bytes[i++] = (byte)(ProfileBegin % 256);
|
|
bytes[i++] = (byte)((ProfileBegin >> 8) % 256);
|
|
bytes[i++] = (byte)(ProfileEnd % 256);
|
|
bytes[i++] = (byte)((ProfileEnd >> 8) % 256);
|
|
bytes[i++] = (byte)(ProfileHollow % 256);
|
|
bytes[i++] = (byte)((ProfileHollow >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.AppendLine(String.Format("PathCurve: {0}", PathCurve));
|
|
output.AppendLine(String.Format("ProfileCurve: {0}", ProfileCurve));
|
|
output.AppendLine(String.Format("PathBegin: {0}", PathBegin));
|
|
output.AppendLine(String.Format("PathEnd: {0}", PathEnd));
|
|
output.AppendLine(String.Format("PathScaleX: {0}", PathScaleX));
|
|
output.AppendLine(String.Format("PathScaleY: {0}", PathScaleY));
|
|
output.AppendLine(String.Format("PathShearX: {0}", PathShearX));
|
|
output.AppendLine(String.Format("PathShearY: {0}", PathShearY));
|
|
output.AppendLine(String.Format("PathTwist: {0}", PathTwist));
|
|
output.AppendLine(String.Format("PathTwistBegin: {0}", PathTwistBegin));
|
|
output.AppendLine(String.Format("PathRadiusOffset: {0}", PathRadiusOffset));
|
|
output.AppendLine(String.Format("PathTaperX: {0}", PathTaperX));
|
|
output.AppendLine(String.Format("PathTaperY: {0}", PathTaperY));
|
|
output.AppendLine(String.Format("PathRevolutions: {0}", PathRevolutions));
|
|
output.AppendLine(String.Format("PathSkew: {0}", PathSkew));
|
|
output.AppendLine(String.Format("ProfileBegin: {0}", ProfileBegin));
|
|
output.AppendLine(String.Format("ProfileEnd: {0}", ProfileEnd));
|
|
output.Append(String.Format("ProfileHollow: {0}", ProfileHollow));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectShape; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectShapePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 98;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectShapePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectShapePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectShape ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectExtraParamsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public ushort ParamType;
|
|
public bool ParamInUse;
|
|
public uint ParamSize;
|
|
private byte[] _paramdata;
|
|
public byte[] ParamData
|
|
{
|
|
get { return _paramdata; }
|
|
set
|
|
{
|
|
if (value == null) { _paramdata = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _paramdata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _paramdata, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 11;
|
|
if (ParamData != null) { length += 1 + ParamData.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParamType = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ParamInUse = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ParamSize = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_paramdata = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _paramdata, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)(ParamType % 256);
|
|
bytes[i++] = (byte)((ParamType >> 8) % 256);
|
|
bytes[i++] = (byte)((ParamInUse) ? 1 : 0);
|
|
Utils.UIntToBytes(ParamSize, bytes, i); i += 4;
|
|
if(ParamData == null) { Console.WriteLine("Warning: ParamData is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ParamData.Length;
|
|
Buffer.BlockCopy(ParamData, 0, bytes, i, ParamData.Length); i += ParamData.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.AppendLine(String.Format("ParamType: {0}", ParamType));
|
|
output.AppendLine(String.Format("ParamInUse: {0}", ParamInUse));
|
|
output.AppendLine(String.Format("ParamSize: {0}", ParamSize));
|
|
Helpers.FieldToString(output, ParamData, "ParamData");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectExtraParams; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectExtraParamsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 99;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectExtraParamsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectExtraParamsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectExtraParams ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectOwnerPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HeaderDataBlock : PacketBlock
|
|
{
|
|
public bool Override;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public HeaderDataBlock() { }
|
|
public HeaderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Override = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((Override) ? 1 : 0);
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HeaderData --");
|
|
output.AppendLine(String.Format("Override: {0}", Override));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectOwner; } }
|
|
public AgentDataBlock AgentData;
|
|
public HeaderDataBlock HeaderData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectOwnerPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 100;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
HeaderData = new HeaderDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectOwnerPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectOwnerPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += HeaderData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
HeaderData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectOwner ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += HeaderData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectGroupPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectGroup; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectGroupPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 101;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectGroupPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectGroupPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectGroup ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectBuyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
public UUID CategoryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
CategoryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CategoryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("CategoryID: {0}", CategoryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 9;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.Append(String.Format("SalePrice: {0}", SalePrice));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectBuy; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectBuyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 102;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectBuyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectBuyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectBuy ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class BuyObjectInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.BuyObjectInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public BuyObjectInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 103;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public BuyObjectInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public BuyObjectInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- BuyObjectInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DerezContainerPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public bool Delete;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
Delete = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Delete) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("Delete: {0}", Delete));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DerezContainer; } }
|
|
public DataBlock Data;
|
|
|
|
public DerezContainerPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 104;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public DerezContainerPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DerezContainerPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DerezContainer ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectPermissionsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HeaderDataBlock : PacketBlock
|
|
{
|
|
public bool Override;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public HeaderDataBlock() { }
|
|
public HeaderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Override = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((Override) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HeaderData --");
|
|
output.Append(String.Format("Override: {0}", Override));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public byte Field;
|
|
public byte Set;
|
|
public uint Mask;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Field = (byte)bytes[i++];
|
|
Set = (byte)bytes[i++];
|
|
Mask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = Field;
|
|
bytes[i++] = Set;
|
|
Utils.UIntToBytes(Mask, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.AppendLine(String.Format("Field: {0}", Field));
|
|
output.AppendLine(String.Format("Set: {0}", Set));
|
|
output.Append(String.Format("Mask: {0}", Mask));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectPermissions; } }
|
|
public AgentDataBlock AgentData;
|
|
public HeaderDataBlock HeaderData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectPermissionsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 105;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
HeaderData = new HeaderDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectPermissionsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectPermissionsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += HeaderData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
HeaderData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectPermissions ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += HeaderData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectSaleInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 9;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.Append(String.Format("SalePrice: {0}", SalePrice));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectSaleInfo; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectSaleInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 106;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectSaleInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectSaleInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectSaleInfo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectNamePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectName; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectNamePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 107;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectNamePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectNamePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectName ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDescriptionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDescription; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDescriptionPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 108;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDescriptionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDescriptionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDescription ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectCategoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
public uint Category;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Category, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("Category: {0}", Category));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectCategory; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectCategoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 109;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectCategoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectCategoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectCategory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectSelectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectSelect; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectSelectPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 110;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectSelectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectSelectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectSelect ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDeselectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDeselect; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDeselectPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 111;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDeselectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDeselectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDeselect ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectAttachPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public byte AttachmentPoint;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
AttachmentPoint = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = AttachmentPoint;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("AttachmentPoint: {0}", AttachmentPoint));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public Quaternion Rotation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Rotation.FromBytes(bytes, i, true); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("Rotation: {0}", Rotation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectAttach; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectAttachPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 112;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectAttachPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectAttachPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectAttach ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDetachPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDetach; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDetachPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 113;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDetachPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDetachPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDetach ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDropPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDrop; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDropPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 114;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDropPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDropPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDrop ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectLinkPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectLink; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectLinkPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 115;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectLinkPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectLinkPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectLink ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDelinkPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDelink; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectDelinkPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 116;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectDelinkPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDelinkPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDelink ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectGrabPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
public Vector3 GrabOffset;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GrabOffset.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(GrabOffset.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("GrabOffset: {0}", GrabOffset));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SurfaceInfoBlock : PacketBlock
|
|
{
|
|
public Vector3 UVCoord;
|
|
public Vector3 STCoord;
|
|
public int FaceIndex;
|
|
public Vector3 Position;
|
|
public Vector3 Normal;
|
|
public Vector3 Binormal;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public SurfaceInfoBlock() { }
|
|
public SurfaceInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
UVCoord.FromBytes(bytes, i); i += 12;
|
|
STCoord.FromBytes(bytes, i); i += 12;
|
|
FaceIndex = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
Normal.FromBytes(bytes, i); i += 12;
|
|
Binormal.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(UVCoord.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(STCoord.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.IntToBytes(FaceIndex, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Normal.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Binormal.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SurfaceInfo --");
|
|
output.AppendLine(String.Format("UVCoord: {0}", UVCoord));
|
|
output.AppendLine(String.Format("STCoord: {0}", STCoord));
|
|
output.AppendLine(String.Format("FaceIndex: {0}", FaceIndex));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("Normal: {0}", Normal));
|
|
output.Append(String.Format("Binormal: {0}", Binormal));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectGrab; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
public SurfaceInfoBlock[] SurfaceInfo;
|
|
|
|
public ObjectGrabPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 117;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
SurfaceInfo = new SurfaceInfoBlock[0];
|
|
}
|
|
|
|
public ObjectGrabPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SurfaceInfo.Length < count) {
|
|
SurfaceInfo = new SurfaceInfoBlock[count];
|
|
for(int j = 0; j < count; j++) SurfaceInfo[j] = new SurfaceInfoBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SurfaceInfo[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectGrabPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SurfaceInfo.Length < count) {
|
|
SurfaceInfo = new SurfaceInfoBlock[count];
|
|
for(int j = 0; j < count; j++) SurfaceInfo[j] = new SurfaceInfoBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SurfaceInfo[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++) { length += SurfaceInfo[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)SurfaceInfo.Length;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++) { SurfaceInfo[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectGrab ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++)
|
|
{
|
|
output += SurfaceInfo[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectGrabUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public Vector3 GrabOffsetInitial;
|
|
public Vector3 GrabPosition;
|
|
public uint TimeSinceLast;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 44;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
GrabOffsetInitial.FromBytes(bytes, i); i += 12;
|
|
GrabPosition.FromBytes(bytes, i); i += 12;
|
|
TimeSinceLast = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GrabOffsetInitial.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(GrabPosition.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.UIntToBytes(TimeSinceLast, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("GrabOffsetInitial: {0}", GrabOffsetInitial));
|
|
output.AppendLine(String.Format("GrabPosition: {0}", GrabPosition));
|
|
output.Append(String.Format("TimeSinceLast: {0}", TimeSinceLast));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SurfaceInfoBlock : PacketBlock
|
|
{
|
|
public Vector3 UVCoord;
|
|
public Vector3 STCoord;
|
|
public int FaceIndex;
|
|
public Vector3 Position;
|
|
public Vector3 Normal;
|
|
public Vector3 Binormal;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public SurfaceInfoBlock() { }
|
|
public SurfaceInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
UVCoord.FromBytes(bytes, i); i += 12;
|
|
STCoord.FromBytes(bytes, i); i += 12;
|
|
FaceIndex = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
Normal.FromBytes(bytes, i); i += 12;
|
|
Binormal.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(UVCoord.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(STCoord.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.IntToBytes(FaceIndex, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Normal.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Binormal.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SurfaceInfo --");
|
|
output.AppendLine(String.Format("UVCoord: {0}", UVCoord));
|
|
output.AppendLine(String.Format("STCoord: {0}", STCoord));
|
|
output.AppendLine(String.Format("FaceIndex: {0}", FaceIndex));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("Normal: {0}", Normal));
|
|
output.Append(String.Format("Binormal: {0}", Binormal));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectGrabUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
public SurfaceInfoBlock[] SurfaceInfo;
|
|
|
|
public ObjectGrabUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 118;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
SurfaceInfo = new SurfaceInfoBlock[0];
|
|
}
|
|
|
|
public ObjectGrabUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SurfaceInfo.Length < count) {
|
|
SurfaceInfo = new SurfaceInfoBlock[count];
|
|
for(int j = 0; j < count; j++) SurfaceInfo[j] = new SurfaceInfoBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SurfaceInfo[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectGrabUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SurfaceInfo.Length < count) {
|
|
SurfaceInfo = new SurfaceInfoBlock[count];
|
|
for(int j = 0; j < count; j++) SurfaceInfo[j] = new SurfaceInfoBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SurfaceInfo[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++) { length += SurfaceInfo[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)SurfaceInfo.Length;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++) { SurfaceInfo[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectGrabUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++)
|
|
{
|
|
output += SurfaceInfo[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDeGrabPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SurfaceInfoBlock : PacketBlock
|
|
{
|
|
public Vector3 UVCoord;
|
|
public Vector3 STCoord;
|
|
public int FaceIndex;
|
|
public Vector3 Position;
|
|
public Vector3 Normal;
|
|
public Vector3 Binormal;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public SurfaceInfoBlock() { }
|
|
public SurfaceInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
UVCoord.FromBytes(bytes, i); i += 12;
|
|
STCoord.FromBytes(bytes, i); i += 12;
|
|
FaceIndex = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
Normal.FromBytes(bytes, i); i += 12;
|
|
Binormal.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(UVCoord.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(STCoord.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.IntToBytes(FaceIndex, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Normal.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Binormal.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SurfaceInfo --");
|
|
output.AppendLine(String.Format("UVCoord: {0}", UVCoord));
|
|
output.AppendLine(String.Format("STCoord: {0}", STCoord));
|
|
output.AppendLine(String.Format("FaceIndex: {0}", FaceIndex));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("Normal: {0}", Normal));
|
|
output.Append(String.Format("Binormal: {0}", Binormal));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectDeGrab; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
public SurfaceInfoBlock[] SurfaceInfo;
|
|
|
|
public ObjectDeGrabPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 119;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
SurfaceInfo = new SurfaceInfoBlock[0];
|
|
}
|
|
|
|
public ObjectDeGrabPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SurfaceInfo.Length < count) {
|
|
SurfaceInfo = new SurfaceInfoBlock[count];
|
|
for(int j = 0; j < count; j++) SurfaceInfo[j] = new SurfaceInfoBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SurfaceInfo[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectDeGrabPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SurfaceInfo.Length < count) {
|
|
SurfaceInfo = new SurfaceInfoBlock[count];
|
|
for(int j = 0; j < count; j++) SurfaceInfo[j] = new SurfaceInfoBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SurfaceInfo[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++) { length += SurfaceInfo[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)SurfaceInfo.Length;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++) { SurfaceInfo[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectDeGrab ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < SurfaceInfo.Length; j++)
|
|
{
|
|
output += SurfaceInfo[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectSpinStartPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectSpinStart; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public ObjectSpinStartPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 120;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public ObjectSpinStartPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ObjectSpinStartPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectSpinStart ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectSpinUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public Quaternion Rotation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 28;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
Rotation.FromBytes(bytes, i, true); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("Rotation: {0}", Rotation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectSpinUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public ObjectSpinUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 121;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public ObjectSpinUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ObjectSpinUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectSpinUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectSpinStopPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectSpinStop; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public ObjectSpinStopPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 122;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public ObjectSpinStopPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ObjectSpinStopPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectSpinStop ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectExportSelectedPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID RequestID;
|
|
public short VolumeDetail;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 34;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
VolumeDetail = (short)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)(VolumeDetail % 256);
|
|
bytes[i++] = (byte)((VolumeDetail >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.Append(String.Format("VolumeDetail: {0}", VolumeDetail));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectExportSelected; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectExportSelectedPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 123;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectExportSelectedPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectExportSelectedPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectExportSelected ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ModifyLandPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ModifyBlockBlock : PacketBlock
|
|
{
|
|
public byte Action;
|
|
public byte BrushSize;
|
|
public float Seconds;
|
|
public float Height;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
public ModifyBlockBlock() { }
|
|
public ModifyBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Action = (byte)bytes[i++];
|
|
BrushSize = (byte)bytes[i++];
|
|
Seconds = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Height = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = Action;
|
|
bytes[i++] = BrushSize;
|
|
Utils.FloatToBytes(Seconds, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Height, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ModifyBlock --");
|
|
output.AppendLine(String.Format("Action: {0}", Action));
|
|
output.AppendLine(String.Format("BrushSize: {0}", BrushSize));
|
|
output.AppendLine(String.Format("Seconds: {0}", Seconds));
|
|
output.Append(String.Format("Height: {0}", Height));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public float West;
|
|
public float South;
|
|
public float East;
|
|
public float North;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
West = Utils.BytesToFloat(bytes, i); i += 4;
|
|
South = Utils.BytesToFloat(bytes, i); i += 4;
|
|
East = Utils.BytesToFloat(bytes, i); i += 4;
|
|
North = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.FloatToBytes(West, bytes, i); i += 4;
|
|
Utils.FloatToBytes(South, bytes, i); i += 4;
|
|
Utils.FloatToBytes(East, bytes, i); i += 4;
|
|
Utils.FloatToBytes(North, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.AppendLine(String.Format("West: {0}", West));
|
|
output.AppendLine(String.Format("South: {0}", South));
|
|
output.AppendLine(String.Format("East: {0}", East));
|
|
output.Append(String.Format("North: {0}", North));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ModifyLand; } }
|
|
public AgentDataBlock AgentData;
|
|
public ModifyBlockBlock ModifyBlock;
|
|
public ParcelDataBlock[] ParcelData;
|
|
|
|
public ModifyLandPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 124;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ModifyBlock = new ModifyBlockBlock();
|
|
ParcelData = new ParcelDataBlock[0];
|
|
}
|
|
|
|
public ModifyLandPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ModifyBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParcelData.Length < count) {
|
|
ParcelData = new ParcelDataBlock[count];
|
|
for(int j = 0; j < count; j++) ParcelData[j] = new ParcelDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParcelData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ModifyLandPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ModifyBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParcelData.Length < count) {
|
|
ParcelData = new ParcelDataBlock[count];
|
|
for(int j = 0; j < count; j++) ParcelData[j] = new ParcelDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParcelData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ModifyBlock.Length;;
|
|
length++;
|
|
for (int j = 0; j < ParcelData.Length; j++) { length += ParcelData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ModifyBlock.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ParcelData.Length;
|
|
for (int j = 0; j < ParcelData.Length; j++) { ParcelData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ModifyLand ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ModifyBlock.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ParcelData.Length; j++)
|
|
{
|
|
output += ParcelData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class VelocityInterpolateOnPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.VelocityInterpolateOn; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public VelocityInterpolateOnPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 125;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public VelocityInterpolateOnPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public VelocityInterpolateOnPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- VelocityInterpolateOn ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class VelocityInterpolateOffPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.VelocityInterpolateOff; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public VelocityInterpolateOffPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 126;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public VelocityInterpolateOffPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public VelocityInterpolateOffPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- VelocityInterpolateOff ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class StateSavePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
private byte[] _filename;
|
|
public byte[] Filename
|
|
{
|
|
get { return _filename; }
|
|
set
|
|
{
|
|
if (value == null) { _filename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Filename != null) { length += 1 + Filename.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_filename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Filename.Length;
|
|
Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
Helpers.FieldToString(output, Filename, "Filename");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.StateSave; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlockBlock DataBlock;
|
|
|
|
public StateSavePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 127;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
DataBlock = new DataBlockBlock();
|
|
}
|
|
|
|
public StateSavePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public StateSavePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += DataBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- StateSave ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ReportAutosaveCrashPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AutosaveDataBlock : PacketBlock
|
|
{
|
|
public int PID;
|
|
public int Status;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public AutosaveDataBlock() { }
|
|
public AutosaveDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Status = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(PID, bytes, i); i += 4;
|
|
Utils.IntToBytes(Status, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AutosaveData --");
|
|
output.AppendLine(String.Format("PID: {0}", PID));
|
|
output.Append(String.Format("Status: {0}", Status));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ReportAutosaveCrash; } }
|
|
public AutosaveDataBlock AutosaveData;
|
|
|
|
public ReportAutosaveCrashPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 128;
|
|
Header.Reliable = true;
|
|
AutosaveData = new AutosaveDataBlock();
|
|
}
|
|
|
|
public ReportAutosaveCrashPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AutosaveData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ReportAutosaveCrashPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AutosaveData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AutosaveData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AutosaveData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ReportAutosaveCrash ---" + Environment.NewLine;
|
|
output += AutosaveData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SimWideDeletesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
output.AppendLine(String.Format("TargetID: {0}", TargetID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SimWideDeletes; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlockBlock DataBlock;
|
|
|
|
public SimWideDeletesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 129;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
DataBlock = new DataBlockBlock();
|
|
}
|
|
|
|
public SimWideDeletesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SimWideDeletesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += DataBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SimWideDeletes ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TrackAgentPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TargetDataBlock : PacketBlock
|
|
{
|
|
public UUID PreyID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TargetDataBlock() { }
|
|
public TargetDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PreyID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(PreyID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TargetData --");
|
|
output.Append(String.Format("PreyID: {0}", PreyID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TrackAgent; } }
|
|
public AgentDataBlock AgentData;
|
|
public TargetDataBlock TargetData;
|
|
|
|
public TrackAgentPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 130;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
TargetData = new TargetDataBlock();
|
|
}
|
|
|
|
public TrackAgentPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TargetData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TrackAgentPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TargetData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TargetData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TargetData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TrackAgent ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TargetData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ViewerStatsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint IP;
|
|
public uint StartTime;
|
|
public float RunTime;
|
|
public float SimFPS;
|
|
public float FPS;
|
|
public byte AgentsInView;
|
|
public float Ping;
|
|
public double MetersTraveled;
|
|
public int RegionsVisited;
|
|
public uint SysRAM;
|
|
private byte[] _sysos;
|
|
public byte[] SysOS
|
|
{
|
|
get { return _sysos; }
|
|
set
|
|
{
|
|
if (value == null) { _sysos = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _sysos = new byte[value.Length]; Buffer.BlockCopy(value, 0, _sysos, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _syscpu;
|
|
public byte[] SysCPU
|
|
{
|
|
get { return _syscpu; }
|
|
set
|
|
{
|
|
if (value == null) { _syscpu = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _syscpu = new byte[value.Length]; Buffer.BlockCopy(value, 0, _syscpu, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _sysgpu;
|
|
public byte[] SysGPU
|
|
{
|
|
get { return _sysgpu; }
|
|
set
|
|
{
|
|
if (value == null) { _sysgpu = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _sysgpu = new byte[value.Length]; Buffer.BlockCopy(value, 0, _sysgpu, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 73;
|
|
if (SysOS != null) { length += 1 + SysOS.Length; }
|
|
if (SysCPU != null) { length += 1 + SysCPU.Length; }
|
|
if (SysGPU != null) { length += 1 + SysGPU.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
IP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
StartTime = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RunTime = Utils.BytesToFloat(bytes, i); i += 4;
|
|
SimFPS = Utils.BytesToFloat(bytes, i); i += 4;
|
|
FPS = Utils.BytesToFloat(bytes, i); i += 4;
|
|
AgentsInView = (byte)bytes[i++];
|
|
Ping = Utils.BytesToFloat(bytes, i); i += 4;
|
|
MetersTraveled = Utils.BytesToDouble(bytes, i); i += 8;
|
|
RegionsVisited = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SysRAM = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_sysos = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _sysos, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_syscpu = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _syscpu, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_sysgpu = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _sysgpu, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(IP, bytes, i); i += 4;
|
|
Utils.UIntToBytes(StartTime, bytes, i); i += 4;
|
|
Utils.FloatToBytes(RunTime, bytes, i); i += 4;
|
|
Utils.FloatToBytes(SimFPS, bytes, i); i += 4;
|
|
Utils.FloatToBytes(FPS, bytes, i); i += 4;
|
|
bytes[i++] = AgentsInView;
|
|
Utils.FloatToBytes(Ping, bytes, i); i += 4;
|
|
Utils.DoubleToBytes(MetersTraveled, bytes, i); i += 8;
|
|
Utils.IntToBytes(RegionsVisited, bytes, i); i += 4;
|
|
Utils.UIntToBytes(SysRAM, bytes, i); i += 4;
|
|
if(SysOS == null) { Console.WriteLine("Warning: SysOS is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SysOS.Length;
|
|
Buffer.BlockCopy(SysOS, 0, bytes, i, SysOS.Length); i += SysOS.Length;
|
|
if(SysCPU == null) { Console.WriteLine("Warning: SysCPU is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SysCPU.Length;
|
|
Buffer.BlockCopy(SysCPU, 0, bytes, i, SysCPU.Length); i += SysCPU.Length;
|
|
if(SysGPU == null) { Console.WriteLine("Warning: SysGPU is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SysGPU.Length;
|
|
Buffer.BlockCopy(SysGPU, 0, bytes, i, SysGPU.Length); i += SysGPU.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("IP: {0}", IP));
|
|
output.AppendLine(String.Format("StartTime: {0}", StartTime));
|
|
output.AppendLine(String.Format("RunTime: {0}", RunTime));
|
|
output.AppendLine(String.Format("SimFPS: {0}", SimFPS));
|
|
output.AppendLine(String.Format("FPS: {0}", FPS));
|
|
output.AppendLine(String.Format("AgentsInView: {0}", AgentsInView));
|
|
output.AppendLine(String.Format("Ping: {0}", Ping));
|
|
output.AppendLine(String.Format("MetersTraveled: {0}", MetersTraveled));
|
|
output.AppendLine(String.Format("RegionsVisited: {0}", RegionsVisited));
|
|
output.AppendLine(String.Format("SysRAM: {0}", SysRAM));
|
|
Helpers.FieldToString(output, SysOS, "SysOS");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, SysCPU, "SysCPU");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, SysGPU, "SysGPU");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DownloadTotalsBlock : PacketBlock
|
|
{
|
|
public uint World;
|
|
public uint Objects;
|
|
public uint Textures;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public DownloadTotalsBlock() { }
|
|
public DownloadTotalsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
World = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Objects = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Textures = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(World, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Objects, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Textures, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DownloadTotals --");
|
|
output.AppendLine(String.Format("World: {0}", World));
|
|
output.AppendLine(String.Format("Objects: {0}", Objects));
|
|
output.Append(String.Format("Textures: {0}", Textures));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NetStatsBlock : PacketBlock
|
|
{
|
|
public uint Bytes;
|
|
public uint Packets;
|
|
public uint Compressed;
|
|
public uint Savings;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public NetStatsBlock() { }
|
|
public NetStatsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Bytes = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Packets = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Compressed = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Savings = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Bytes, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Packets, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Compressed, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Savings, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NetStats --");
|
|
output.AppendLine(String.Format("Bytes: {0}", Bytes));
|
|
output.AppendLine(String.Format("Packets: {0}", Packets));
|
|
output.AppendLine(String.Format("Compressed: {0}", Compressed));
|
|
output.Append(String.Format("Savings: {0}", Savings));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FailStatsBlock : PacketBlock
|
|
{
|
|
public uint SendPacket;
|
|
public uint Dropped;
|
|
public uint Resent;
|
|
public uint FailedResends;
|
|
public uint OffCircuit;
|
|
public uint Invalid;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public FailStatsBlock() { }
|
|
public FailStatsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SendPacket = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Dropped = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Resent = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
FailedResends = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OffCircuit = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Invalid = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(SendPacket, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Dropped, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Resent, bytes, i); i += 4;
|
|
Utils.UIntToBytes(FailedResends, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OffCircuit, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Invalid, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FailStats --");
|
|
output.AppendLine(String.Format("SendPacket: {0}", SendPacket));
|
|
output.AppendLine(String.Format("Dropped: {0}", Dropped));
|
|
output.AppendLine(String.Format("Resent: {0}", Resent));
|
|
output.AppendLine(String.Format("FailedResends: {0}", FailedResends));
|
|
output.AppendLine(String.Format("OffCircuit: {0}", OffCircuit));
|
|
output.Append(String.Format("Invalid: {0}", Invalid));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MiscStatsBlock : PacketBlock
|
|
{
|
|
public uint Type;
|
|
public double Value;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public MiscStatsBlock() { }
|
|
public MiscStatsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Type = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Value = Utils.BytesToDouble(bytes, i); i += 8;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Type, bytes, i); i += 4;
|
|
Utils.DoubleToBytes(Value, bytes, i); i += 8;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MiscStats --");
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.Append(String.Format("Value: {0}", Value));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ViewerStats; } }
|
|
public AgentDataBlock AgentData;
|
|
public DownloadTotalsBlock DownloadTotals;
|
|
public NetStatsBlock[] NetStats;
|
|
public FailStatsBlock FailStats;
|
|
public MiscStatsBlock[] MiscStats;
|
|
|
|
public ViewerStatsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 131;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
DownloadTotals = new DownloadTotalsBlock();
|
|
NetStats = new NetStatsBlock[2];
|
|
FailStats = new FailStatsBlock();
|
|
MiscStats = new MiscStatsBlock[0];
|
|
}
|
|
|
|
public ViewerStatsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
DownloadTotals.FromBytes(bytes, ref i);
|
|
if(NetStats.Length < 2) {
|
|
NetStats = new NetStatsBlock[2];
|
|
for(int j = 0; j < 2; j++) NetStats[j] = new NetStatsBlock();
|
|
}
|
|
for (int j = 0; j < 2; j++)
|
|
{ NetStats[j].FromBytes(bytes, ref i); }
|
|
FailStats.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(MiscStats.Length < count) {
|
|
MiscStats = new MiscStatsBlock[count];
|
|
for(int j = 0; j < count; j++) MiscStats[j] = new MiscStatsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MiscStats[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ViewerStatsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
DownloadTotals.FromBytes(bytes, ref i);
|
|
if(NetStats.Length < 2) {
|
|
NetStats = new NetStatsBlock[2];
|
|
for(int j = 0; j < 2; j++) NetStats[j] = new NetStatsBlock();
|
|
}
|
|
for (int j = 0; j < 2; j++)
|
|
{ NetStats[j].FromBytes(bytes, ref i); }
|
|
FailStats.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(MiscStats.Length < count) {
|
|
MiscStats = new MiscStatsBlock[count];
|
|
for(int j = 0; j < count; j++) MiscStats[j] = new MiscStatsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MiscStats[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += DownloadTotals.Length; length += FailStats.Length;;
|
|
for (int j = 0; j < 2; j++) { length += NetStats[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < MiscStats.Length; j++) { length += MiscStats[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
DownloadTotals.ToBytes(bytes, ref i);
|
|
for (int j = 0; j < 2; j++) { NetStats[j].ToBytes(bytes, ref i); }
|
|
FailStats.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)MiscStats.Length;
|
|
for (int j = 0; j < MiscStats.Length; j++) { MiscStats[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ViewerStats ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += DownloadTotals.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < 2; j++)
|
|
{
|
|
output += NetStats[j].ToString() + Environment.NewLine;
|
|
}
|
|
output += FailStats.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < MiscStats.Length; j++)
|
|
{
|
|
output += MiscStats[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptAnswerYesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID TaskID;
|
|
public UUID ItemID;
|
|
public int Questions;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TaskID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
Questions = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Questions, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TaskID: {0}", TaskID));
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("Questions: {0}", Questions));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptAnswerYes; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ScriptAnswerYesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 132;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ScriptAnswerYesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptAnswerYesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptAnswerYes ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UserReportPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ReportDataBlock : PacketBlock
|
|
{
|
|
public byte ReportType;
|
|
public byte Category;
|
|
public Vector3 Position;
|
|
public byte CheckFlags;
|
|
public UUID ScreenshotID;
|
|
public UUID ObjectID;
|
|
public UUID AbuserID;
|
|
private byte[] _abuseregionname;
|
|
public byte[] AbuseRegionName
|
|
{
|
|
get { return _abuseregionname; }
|
|
set
|
|
{
|
|
if (value == null) { _abuseregionname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _abuseregionname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _abuseregionname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID AbuseRegionID;
|
|
private byte[] _summary;
|
|
public byte[] Summary
|
|
{
|
|
get { return _summary; }
|
|
set
|
|
{
|
|
if (value == null) { _summary = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _summary = new byte[value.Length]; Buffer.BlockCopy(value, 0, _summary, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _details;
|
|
public byte[] Details
|
|
{
|
|
get { return _details; }
|
|
set
|
|
{
|
|
if (value == null) { _details = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _details = new byte[value.Length]; Buffer.BlockCopy(value, 0, _details, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _versionstring;
|
|
public byte[] VersionString
|
|
{
|
|
get { return _versionstring; }
|
|
set
|
|
{
|
|
if (value == null) { _versionstring = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _versionstring = new byte[value.Length]; Buffer.BlockCopy(value, 0, _versionstring, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 79;
|
|
if (AbuseRegionName != null) { length += 1 + AbuseRegionName.Length; }
|
|
if (Summary != null) { length += 1 + Summary.Length; }
|
|
if (Details != null) { length += 2 + Details.Length; }
|
|
if (VersionString != null) { length += 1 + VersionString.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ReportDataBlock() { }
|
|
public ReportDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ReportType = (byte)bytes[i++];
|
|
Category = (byte)bytes[i++];
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
CheckFlags = (byte)bytes[i++];
|
|
ScreenshotID.FromBytes(bytes, i); i += 16;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
AbuserID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_abuseregionname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _abuseregionname, 0, length); i += length;
|
|
AbuseRegionID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_summary = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _summary, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_details = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _details, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_versionstring = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _versionstring, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = ReportType;
|
|
bytes[i++] = Category;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = CheckFlags;
|
|
Buffer.BlockCopy(ScreenshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AbuserID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(AbuseRegionName == null) { Console.WriteLine("Warning: AbuseRegionName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)AbuseRegionName.Length;
|
|
Buffer.BlockCopy(AbuseRegionName, 0, bytes, i, AbuseRegionName.Length); i += AbuseRegionName.Length;
|
|
Buffer.BlockCopy(AbuseRegionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Summary == null) { Console.WriteLine("Warning: Summary is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Summary.Length;
|
|
Buffer.BlockCopy(Summary, 0, bytes, i, Summary.Length); i += Summary.Length;
|
|
if(Details == null) { Console.WriteLine("Warning: Details is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Details.Length % 256);
|
|
bytes[i++] = (byte)((Details.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Details, 0, bytes, i, Details.Length); i += Details.Length;
|
|
if(VersionString == null) { Console.WriteLine("Warning: VersionString is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)VersionString.Length;
|
|
Buffer.BlockCopy(VersionString, 0, bytes, i, VersionString.Length); i += VersionString.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ReportData --");
|
|
output.AppendLine(String.Format("ReportType: {0}", ReportType));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("CheckFlags: {0}", CheckFlags));
|
|
output.AppendLine(String.Format("ScreenshotID: {0}", ScreenshotID));
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("AbuserID: {0}", AbuserID));
|
|
Helpers.FieldToString(output, AbuseRegionName, "AbuseRegionName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("AbuseRegionID: {0}", AbuseRegionID));
|
|
Helpers.FieldToString(output, Summary, "Summary");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Details, "Details");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, VersionString, "VersionString");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UserReport; } }
|
|
public AgentDataBlock AgentData;
|
|
public ReportDataBlock ReportData;
|
|
|
|
public UserReportPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 133;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ReportData = new ReportDataBlock();
|
|
}
|
|
|
|
public UserReportPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ReportData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UserReportPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ReportData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ReportData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ReportData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UserReport ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ReportData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AlertMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AlertDataBlock : PacketBlock
|
|
{
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Message != null) { length += 1 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AlertDataBlock() { }
|
|
public AlertDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Message.Length;
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AlertData --");
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AlertMessage; } }
|
|
public AlertDataBlock AlertData;
|
|
|
|
public AlertMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 134;
|
|
Header.Reliable = true;
|
|
AlertData = new AlertDataBlock();
|
|
}
|
|
|
|
public AlertMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AlertData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AlertMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AlertData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AlertData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AlertData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AlertMessage ---" + Environment.NewLine;
|
|
output += AlertData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentAlertMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AlertDataBlock : PacketBlock
|
|
{
|
|
public bool Modal;
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 1;
|
|
if (Message != null) { length += 1 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AlertDataBlock() { }
|
|
public AlertDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
Modal = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((Modal) ? 1 : 0);
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Message.Length;
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AlertData --");
|
|
output.AppendLine(String.Format("Modal: {0}", Modal));
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentAlertMessage; } }
|
|
public AgentDataBlock AgentData;
|
|
public AlertDataBlock AlertData;
|
|
|
|
public AgentAlertMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 135;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
AlertData = new AlertDataBlock();
|
|
}
|
|
|
|
public AgentAlertMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
AlertData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentAlertMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
AlertData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += AlertData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
AlertData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentAlertMessage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += AlertData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MeanCollisionAlertPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class MeanCollisionBlock : PacketBlock
|
|
{
|
|
public UUID Victim;
|
|
public UUID Perp;
|
|
public uint Time;
|
|
public float Mag;
|
|
public byte Type;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 41;
|
|
}
|
|
}
|
|
|
|
public MeanCollisionBlock() { }
|
|
public MeanCollisionBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Victim.FromBytes(bytes, i); i += 16;
|
|
Perp.FromBytes(bytes, i); i += 16;
|
|
Time = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Mag = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Type = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Victim.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Perp.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Time, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Mag, bytes, i); i += 4;
|
|
bytes[i++] = Type;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MeanCollision --");
|
|
output.AppendLine(String.Format("Victim: {0}", Victim));
|
|
output.AppendLine(String.Format("Perp: {0}", Perp));
|
|
output.AppendLine(String.Format("Time: {0}", Time));
|
|
output.AppendLine(String.Format("Mag: {0}", Mag));
|
|
output.Append(String.Format("Type: {0}", Type));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MeanCollisionAlert; } }
|
|
public MeanCollisionBlock[] MeanCollision;
|
|
|
|
public MeanCollisionAlertPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 136;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
MeanCollision = new MeanCollisionBlock[0];
|
|
}
|
|
|
|
public MeanCollisionAlertPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(MeanCollision.Length < count) {
|
|
MeanCollision = new MeanCollisionBlock[count];
|
|
for(int j = 0; j < count; j++) MeanCollision[j] = new MeanCollisionBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MeanCollision[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MeanCollisionAlertPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(MeanCollision.Length < count) {
|
|
MeanCollision = new MeanCollisionBlock[count];
|
|
for(int j = 0; j < count; j++) MeanCollision[j] = new MeanCollisionBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MeanCollision[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < MeanCollision.Length; j++) { length += MeanCollision[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)MeanCollision.Length;
|
|
for (int j = 0; j < MeanCollision.Length; j++) { MeanCollision[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MeanCollisionAlert ---" + Environment.NewLine;
|
|
for (int j = 0; j < MeanCollision.Length; j++)
|
|
{
|
|
output += MeanCollision[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ViewerFrozenMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class FrozenDataBlock : PacketBlock
|
|
{
|
|
public bool Data;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public FrozenDataBlock() { }
|
|
public FrozenDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Data = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((Data) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FrozenData --");
|
|
output.Append(String.Format("Data: {0}", Data));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ViewerFrozenMessage; } }
|
|
public FrozenDataBlock FrozenData;
|
|
|
|
public ViewerFrozenMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 137;
|
|
Header.Reliable = true;
|
|
FrozenData = new FrozenDataBlock();
|
|
}
|
|
|
|
public ViewerFrozenMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
FrozenData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ViewerFrozenMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
FrozenData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += FrozenData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
FrozenData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ViewerFrozenMessage ---" + Environment.NewLine;
|
|
output += FrozenData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HealthMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class HealthDataBlock : PacketBlock
|
|
{
|
|
public float Health;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public HealthDataBlock() { }
|
|
public HealthDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Health = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.FloatToBytes(Health, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HealthData --");
|
|
output.Append(String.Format("Health: {0}", Health));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.HealthMessage; } }
|
|
public HealthDataBlock HealthData;
|
|
|
|
public HealthMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 138;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
HealthData = new HealthDataBlock();
|
|
}
|
|
|
|
public HealthMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
HealthData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public HealthMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
HealthData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += HealthData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
HealthData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- HealthMessage ---" + Environment.NewLine;
|
|
output += HealthData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChatFromSimulatorPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ChatDataBlock : PacketBlock
|
|
{
|
|
private byte[] _fromname;
|
|
public byte[] FromName
|
|
{
|
|
get { return _fromname; }
|
|
set
|
|
{
|
|
if (value == null) { _fromname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _fromname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _fromname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID SourceID;
|
|
public UUID OwnerID;
|
|
public byte SourceType;
|
|
public byte ChatType;
|
|
public byte Audible;
|
|
public Vector3 Position;
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 47;
|
|
if (FromName != null) { length += 1 + FromName.Length; }
|
|
if (Message != null) { length += 2 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ChatDataBlock() { }
|
|
public ChatDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_fromname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _fromname, 0, length); i += length;
|
|
SourceID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
SourceType = (byte)bytes[i++];
|
|
ChatType = (byte)bytes[i++];
|
|
Audible = (byte)bytes[i++];
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(FromName == null) { Console.WriteLine("Warning: FromName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FromName.Length;
|
|
Buffer.BlockCopy(FromName, 0, bytes, i, FromName.Length); i += FromName.Length;
|
|
Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = SourceType;
|
|
bytes[i++] = ChatType;
|
|
bytes[i++] = Audible;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Message.Length % 256);
|
|
bytes[i++] = (byte)((Message.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ChatData --");
|
|
Helpers.FieldToString(output, FromName, "FromName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SourceID: {0}", SourceID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("SourceType: {0}", SourceType));
|
|
output.AppendLine(String.Format("ChatType: {0}", ChatType));
|
|
output.AppendLine(String.Format("Audible: {0}", Audible));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChatFromSimulator; } }
|
|
public ChatDataBlock ChatData;
|
|
|
|
public ChatFromSimulatorPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 139;
|
|
Header.Reliable = true;
|
|
ChatData = new ChatDataBlock();
|
|
}
|
|
|
|
public ChatFromSimulatorPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ChatData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ChatFromSimulatorPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ChatData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ChatData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ChatData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChatFromSimulator ---" + Environment.NewLine;
|
|
output += ChatData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SimStatsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionBlock : PacketBlock
|
|
{
|
|
public uint RegionX;
|
|
public uint RegionY;
|
|
public uint RegionFlags;
|
|
public uint ObjectCapacity;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public RegionBlock() { }
|
|
public RegionBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionX = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RegionY = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ObjectCapacity = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(RegionX, bytes, i); i += 4;
|
|
Utils.UIntToBytes(RegionY, bytes, i); i += 4;
|
|
Utils.UIntToBytes(RegionFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ObjectCapacity, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Region --");
|
|
output.AppendLine(String.Format("RegionX: {0}", RegionX));
|
|
output.AppendLine(String.Format("RegionY: {0}", RegionY));
|
|
output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
|
|
output.Append(String.Format("ObjectCapacity: {0}", ObjectCapacity));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class StatBlock : PacketBlock
|
|
{
|
|
public uint StatID;
|
|
public float StatValue;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public StatBlock() { }
|
|
public StatBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
StatID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
StatValue = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(StatID, bytes, i); i += 4;
|
|
Utils.FloatToBytes(StatValue, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Stat --");
|
|
output.AppendLine(String.Format("StatID: {0}", StatID));
|
|
output.Append(String.Format("StatValue: {0}", StatValue));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PidStatBlock : PacketBlock
|
|
{
|
|
public int PID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public PidStatBlock() { }
|
|
public PidStatBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(PID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PidStat --");
|
|
output.Append(String.Format("PID: {0}", PID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SimStats; } }
|
|
public RegionBlock Region;
|
|
public StatBlock[] Stat;
|
|
public PidStatBlock PidStat;
|
|
|
|
public SimStatsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 140;
|
|
Header.Reliable = true;
|
|
Region = new RegionBlock();
|
|
Stat = new StatBlock[0];
|
|
PidStat = new PidStatBlock();
|
|
}
|
|
|
|
public SimStatsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Region.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Stat.Length < count) {
|
|
Stat = new StatBlock[count];
|
|
for(int j = 0; j < count; j++) Stat[j] = new StatBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Stat[j].FromBytes(bytes, ref i); }
|
|
PidStat.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SimStatsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Region.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Stat.Length < count) {
|
|
Stat = new StatBlock[count];
|
|
for(int j = 0; j < count; j++) Stat[j] = new StatBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Stat[j].FromBytes(bytes, ref i); }
|
|
PidStat.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Region.Length; length += PidStat.Length;;
|
|
length++;
|
|
for (int j = 0; j < Stat.Length; j++) { length += Stat[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Region.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Stat.Length;
|
|
for (int j = 0; j < Stat.Length; j++) { Stat[j].ToBytes(bytes, ref i); }
|
|
PidStat.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SimStats ---" + Environment.NewLine;
|
|
output += Region.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Stat.Length; j++)
|
|
{
|
|
output += Stat[j].ToString() + Environment.NewLine;
|
|
}
|
|
output += PidStat.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestRegionInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestRegionInfo; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public RequestRegionInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 141;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public RequestRegionInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestRegionInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestRegionInfo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionInfoBlock : PacketBlock
|
|
{
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint EstateID;
|
|
public uint ParentEstateID;
|
|
public uint RegionFlags;
|
|
public byte SimAccess;
|
|
public byte MaxAgents;
|
|
public float BillableFactor;
|
|
public float ObjectBonusFactor;
|
|
public float WaterHeight;
|
|
public float TerrainRaiseLimit;
|
|
public float TerrainLowerLimit;
|
|
public int PricePerMeter;
|
|
public int RedirectGridX;
|
|
public int RedirectGridY;
|
|
public bool UseEstateSun;
|
|
public float SunHour;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 51;
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RegionInfoBlock() { }
|
|
public RegionInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParentEstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SimAccess = (byte)bytes[i++];
|
|
MaxAgents = (byte)bytes[i++];
|
|
BillableFactor = Utils.BytesToFloat(bytes, i); i += 4;
|
|
ObjectBonusFactor = Utils.BytesToFloat(bytes, i); i += 4;
|
|
WaterHeight = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainRaiseLimit = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainLowerLimit = Utils.BytesToFloat(bytes, i); i += 4;
|
|
PricePerMeter = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RedirectGridX = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RedirectGridY = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
UseEstateSun = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
SunHour = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Utils.UIntToBytes(EstateID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ParentEstateID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(RegionFlags, bytes, i); i += 4;
|
|
bytes[i++] = SimAccess;
|
|
bytes[i++] = MaxAgents;
|
|
Utils.FloatToBytes(BillableFactor, bytes, i); i += 4;
|
|
Utils.FloatToBytes(ObjectBonusFactor, bytes, i); i += 4;
|
|
Utils.FloatToBytes(WaterHeight, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainRaiseLimit, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainLowerLimit, bytes, i); i += 4;
|
|
Utils.IntToBytes(PricePerMeter, bytes, i); i += 4;
|
|
Utils.IntToBytes(RedirectGridX, bytes, i); i += 4;
|
|
Utils.IntToBytes(RedirectGridY, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((UseEstateSun) ? 1 : 0);
|
|
Utils.FloatToBytes(SunHour, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionInfo --");
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("EstateID: {0}", EstateID));
|
|
output.AppendLine(String.Format("ParentEstateID: {0}", ParentEstateID));
|
|
output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
|
|
output.AppendLine(String.Format("SimAccess: {0}", SimAccess));
|
|
output.AppendLine(String.Format("MaxAgents: {0}", MaxAgents));
|
|
output.AppendLine(String.Format("BillableFactor: {0}", BillableFactor));
|
|
output.AppendLine(String.Format("ObjectBonusFactor: {0}", ObjectBonusFactor));
|
|
output.AppendLine(String.Format("WaterHeight: {0}", WaterHeight));
|
|
output.AppendLine(String.Format("TerrainRaiseLimit: {0}", TerrainRaiseLimit));
|
|
output.AppendLine(String.Format("TerrainLowerLimit: {0}", TerrainLowerLimit));
|
|
output.AppendLine(String.Format("PricePerMeter: {0}", PricePerMeter));
|
|
output.AppendLine(String.Format("RedirectGridX: {0}", RedirectGridX));
|
|
output.AppendLine(String.Format("RedirectGridY: {0}", RedirectGridY));
|
|
output.AppendLine(String.Format("UseEstateSun: {0}", UseEstateSun));
|
|
output.Append(String.Format("SunHour: {0}", SunHour));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RegionInfo; } }
|
|
public AgentDataBlock AgentData;
|
|
public RegionInfoBlock RegionInfo;
|
|
|
|
public RegionInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 142;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
RegionInfo = new RegionInfoBlock();
|
|
}
|
|
|
|
public RegionInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RegionInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RegionInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RegionInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RegionInfo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RegionInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GodUpdateRegionInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionInfoBlock : PacketBlock
|
|
{
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint EstateID;
|
|
public uint ParentEstateID;
|
|
public uint RegionFlags;
|
|
public float BillableFactor;
|
|
public int PricePerMeter;
|
|
public int RedirectGridX;
|
|
public int RedirectGridY;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RegionInfoBlock() { }
|
|
public RegionInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParentEstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
BillableFactor = Utils.BytesToFloat(bytes, i); i += 4;
|
|
PricePerMeter = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RedirectGridX = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RedirectGridY = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Utils.UIntToBytes(EstateID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ParentEstateID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(RegionFlags, bytes, i); i += 4;
|
|
Utils.FloatToBytes(BillableFactor, bytes, i); i += 4;
|
|
Utils.IntToBytes(PricePerMeter, bytes, i); i += 4;
|
|
Utils.IntToBytes(RedirectGridX, bytes, i); i += 4;
|
|
Utils.IntToBytes(RedirectGridY, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionInfo --");
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("EstateID: {0}", EstateID));
|
|
output.AppendLine(String.Format("ParentEstateID: {0}", ParentEstateID));
|
|
output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
|
|
output.AppendLine(String.Format("BillableFactor: {0}", BillableFactor));
|
|
output.AppendLine(String.Format("PricePerMeter: {0}", PricePerMeter));
|
|
output.AppendLine(String.Format("RedirectGridX: {0}", RedirectGridX));
|
|
output.Append(String.Format("RedirectGridY: {0}", RedirectGridY));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GodUpdateRegionInfo; } }
|
|
public AgentDataBlock AgentData;
|
|
public RegionInfoBlock RegionInfo;
|
|
|
|
public GodUpdateRegionInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 143;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
RegionInfo = new RegionInfoBlock();
|
|
}
|
|
|
|
public GodUpdateRegionInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GodUpdateRegionInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RegionInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RegionInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GodUpdateRegionInfo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RegionInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NearestLandingRegionUpdatedPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public RegionDataBlock() { }
|
|
public RegionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionData --");
|
|
output.Append(String.Format("RegionHandle: {0}", RegionHandle));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.NearestLandingRegionUpdated; } }
|
|
public RegionDataBlock RegionData;
|
|
|
|
public NearestLandingRegionUpdatedPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 146;
|
|
Header.Reliable = true;
|
|
RegionData = new RegionDataBlock();
|
|
}
|
|
|
|
public NearestLandingRegionUpdatedPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public NearestLandingRegionUpdatedPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += RegionData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RegionData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- NearestLandingRegionUpdated ---" + Environment.NewLine;
|
|
output += RegionData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionHandshakePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionInfoBlock : PacketBlock
|
|
{
|
|
public uint RegionFlags;
|
|
public byte SimAccess;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID SimOwner;
|
|
public bool IsEstateManager;
|
|
public float WaterHeight;
|
|
public float BillableFactor;
|
|
public UUID CacheID;
|
|
public UUID TerrainBase0;
|
|
public UUID TerrainBase1;
|
|
public UUID TerrainBase2;
|
|
public UUID TerrainBase3;
|
|
public UUID TerrainDetail0;
|
|
public UUID TerrainDetail1;
|
|
public UUID TerrainDetail2;
|
|
public UUID TerrainDetail3;
|
|
public float TerrainStartHeight00;
|
|
public float TerrainStartHeight01;
|
|
public float TerrainStartHeight10;
|
|
public float TerrainStartHeight11;
|
|
public float TerrainHeightRange00;
|
|
public float TerrainHeightRange01;
|
|
public float TerrainHeightRange10;
|
|
public float TerrainHeightRange11;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 206;
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RegionInfoBlock() { }
|
|
public RegionInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SimAccess = (byte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
SimOwner.FromBytes(bytes, i); i += 16;
|
|
IsEstateManager = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
WaterHeight = Utils.BytesToFloat(bytes, i); i += 4;
|
|
BillableFactor = Utils.BytesToFloat(bytes, i); i += 4;
|
|
CacheID.FromBytes(bytes, i); i += 16;
|
|
TerrainBase0.FromBytes(bytes, i); i += 16;
|
|
TerrainBase1.FromBytes(bytes, i); i += 16;
|
|
TerrainBase2.FromBytes(bytes, i); i += 16;
|
|
TerrainBase3.FromBytes(bytes, i); i += 16;
|
|
TerrainDetail0.FromBytes(bytes, i); i += 16;
|
|
TerrainDetail1.FromBytes(bytes, i); i += 16;
|
|
TerrainDetail2.FromBytes(bytes, i); i += 16;
|
|
TerrainDetail3.FromBytes(bytes, i); i += 16;
|
|
TerrainStartHeight00 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainStartHeight01 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainStartHeight10 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainStartHeight11 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainHeightRange00 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainHeightRange01 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainHeightRange10 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
TerrainHeightRange11 = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(RegionFlags, bytes, i); i += 4;
|
|
bytes[i++] = SimAccess;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(SimOwner.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsEstateManager) ? 1 : 0);
|
|
Utils.FloatToBytes(WaterHeight, bytes, i); i += 4;
|
|
Utils.FloatToBytes(BillableFactor, bytes, i); i += 4;
|
|
Buffer.BlockCopy(CacheID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainBase0.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainBase1.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainBase2.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainBase3.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainDetail0.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainDetail1.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainDetail2.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TerrainDetail3.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(TerrainStartHeight00, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainStartHeight01, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainStartHeight10, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainStartHeight11, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainHeightRange00, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainHeightRange01, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainHeightRange10, bytes, i); i += 4;
|
|
Utils.FloatToBytes(TerrainHeightRange11, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionInfo --");
|
|
output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
|
|
output.AppendLine(String.Format("SimAccess: {0}", SimAccess));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SimOwner: {0}", SimOwner));
|
|
output.AppendLine(String.Format("IsEstateManager: {0}", IsEstateManager));
|
|
output.AppendLine(String.Format("WaterHeight: {0}", WaterHeight));
|
|
output.AppendLine(String.Format("BillableFactor: {0}", BillableFactor));
|
|
output.AppendLine(String.Format("CacheID: {0}", CacheID));
|
|
output.AppendLine(String.Format("TerrainBase0: {0}", TerrainBase0));
|
|
output.AppendLine(String.Format("TerrainBase1: {0}", TerrainBase1));
|
|
output.AppendLine(String.Format("TerrainBase2: {0}", TerrainBase2));
|
|
output.AppendLine(String.Format("TerrainBase3: {0}", TerrainBase3));
|
|
output.AppendLine(String.Format("TerrainDetail0: {0}", TerrainDetail0));
|
|
output.AppendLine(String.Format("TerrainDetail1: {0}", TerrainDetail1));
|
|
output.AppendLine(String.Format("TerrainDetail2: {0}", TerrainDetail2));
|
|
output.AppendLine(String.Format("TerrainDetail3: {0}", TerrainDetail3));
|
|
output.AppendLine(String.Format("TerrainStartHeight00: {0}", TerrainStartHeight00));
|
|
output.AppendLine(String.Format("TerrainStartHeight01: {0}", TerrainStartHeight01));
|
|
output.AppendLine(String.Format("TerrainStartHeight10: {0}", TerrainStartHeight10));
|
|
output.AppendLine(String.Format("TerrainStartHeight11: {0}", TerrainStartHeight11));
|
|
output.AppendLine(String.Format("TerrainHeightRange00: {0}", TerrainHeightRange00));
|
|
output.AppendLine(String.Format("TerrainHeightRange01: {0}", TerrainHeightRange01));
|
|
output.AppendLine(String.Format("TerrainHeightRange10: {0}", TerrainHeightRange10));
|
|
output.Append(String.Format("TerrainHeightRange11: {0}", TerrainHeightRange11));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionInfo2Block : PacketBlock
|
|
{
|
|
public UUID RegionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public RegionInfo2Block() { }
|
|
public RegionInfo2Block(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionInfo2 --");
|
|
output.Append(String.Format("RegionID: {0}", RegionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RegionHandshake; } }
|
|
public RegionInfoBlock RegionInfo;
|
|
public RegionInfo2Block RegionInfo2;
|
|
|
|
public RegionHandshakePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 148;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
RegionInfo = new RegionInfoBlock();
|
|
RegionInfo2 = new RegionInfo2Block();
|
|
}
|
|
|
|
public RegionHandshakePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
RegionInfo2.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RegionHandshakePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
RegionInfo2.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += RegionInfo.Length; length += RegionInfo2.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RegionInfo.ToBytes(bytes, ref i);
|
|
RegionInfo2.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RegionHandshake ---" + Environment.NewLine;
|
|
output += RegionInfo.ToString() + Environment.NewLine;
|
|
output += RegionInfo2.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionHandshakeReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionInfoBlock : PacketBlock
|
|
{
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public RegionInfoBlock() { }
|
|
public RegionInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionInfo --");
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RegionHandshakeReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public RegionInfoBlock RegionInfo;
|
|
|
|
public RegionHandshakeReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 149;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
RegionInfo = new RegionInfoBlock();
|
|
}
|
|
|
|
public RegionHandshakeReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RegionHandshakeReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RegionInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RegionInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RegionHandshakeReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RegionInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SimulatorViewerTimeMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TimeInfoBlock : PacketBlock
|
|
{
|
|
public ulong UsecSinceStart;
|
|
public uint SecPerDay;
|
|
public uint SecPerYear;
|
|
public Vector3 SunDirection;
|
|
public float SunPhase;
|
|
public Vector3 SunAngVelocity;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 44;
|
|
}
|
|
}
|
|
|
|
public TimeInfoBlock() { }
|
|
public TimeInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
UsecSinceStart = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
SecPerDay = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SecPerYear = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SunDirection.FromBytes(bytes, i); i += 12;
|
|
SunPhase = Utils.BytesToFloat(bytes, i); i += 4;
|
|
SunAngVelocity.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(UsecSinceStart, bytes, i); i += 8;
|
|
Utils.UIntToBytes(SecPerDay, bytes, i); i += 4;
|
|
Utils.UIntToBytes(SecPerYear, bytes, i); i += 4;
|
|
Buffer.BlockCopy(SunDirection.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.FloatToBytes(SunPhase, bytes, i); i += 4;
|
|
Buffer.BlockCopy(SunAngVelocity.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TimeInfo --");
|
|
output.AppendLine(String.Format("UsecSinceStart: {0}", UsecSinceStart));
|
|
output.AppendLine(String.Format("SecPerDay: {0}", SecPerDay));
|
|
output.AppendLine(String.Format("SecPerYear: {0}", SecPerYear));
|
|
output.AppendLine(String.Format("SunDirection: {0}", SunDirection));
|
|
output.AppendLine(String.Format("SunPhase: {0}", SunPhase));
|
|
output.Append(String.Format("SunAngVelocity: {0}", SunAngVelocity));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SimulatorViewerTimeMessage; } }
|
|
public TimeInfoBlock TimeInfo;
|
|
|
|
public SimulatorViewerTimeMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 150;
|
|
Header.Reliable = true;
|
|
TimeInfo = new TimeInfoBlock();
|
|
}
|
|
|
|
public SimulatorViewerTimeMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TimeInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SimulatorViewerTimeMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TimeInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TimeInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TimeInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SimulatorViewerTimeMessage ---" + Environment.NewLine;
|
|
output += TimeInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EnableSimulatorPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class SimulatorInfoBlock : PacketBlock
|
|
{
|
|
public ulong Handle;
|
|
public uint IP;
|
|
public ushort Port;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 14;
|
|
}
|
|
}
|
|
|
|
public SimulatorInfoBlock() { }
|
|
public SimulatorInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Handle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
IP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Port = (ushort)((bytes[i++] << 8) + bytes[i++]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(Handle, bytes, i); i += 8;
|
|
Utils.UIntToBytes(IP, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Port >> 8) % 256);
|
|
bytes[i++] = (byte)(Port % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SimulatorInfo --");
|
|
output.AppendLine(String.Format("Handle: {0}", Handle));
|
|
output.AppendLine(String.Format("IP: {0}", IP));
|
|
output.Append(String.Format("Port: {0}", Port));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EnableSimulator; } }
|
|
public SimulatorInfoBlock SimulatorInfo;
|
|
|
|
public EnableSimulatorPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 151;
|
|
Header.Reliable = true;
|
|
SimulatorInfo = new SimulatorInfoBlock();
|
|
}
|
|
|
|
public EnableSimulatorPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
SimulatorInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EnableSimulatorPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
SimulatorInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += SimulatorInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
SimulatorInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EnableSimulator ---" + Environment.NewLine;
|
|
output += SimulatorInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DisableSimulatorPacket : Packet
|
|
{
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DisableSimulator; } }
|
|
|
|
public DisableSimulatorPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 152;
|
|
Header.Reliable = true;
|
|
}
|
|
|
|
public DisableSimulatorPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public DisableSimulatorPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DisableSimulator ---" + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransferRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TransferInfoBlock : PacketBlock
|
|
{
|
|
public UUID TransferID;
|
|
public int ChannelType;
|
|
public int SourceType;
|
|
public float Priority;
|
|
private byte[] _params;
|
|
public byte[] Params
|
|
{
|
|
get { return _params; }
|
|
set
|
|
{
|
|
if (value == null) { _params = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _params = new byte[value.Length]; Buffer.BlockCopy(value, 0, _params, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (Params != null) { length += 2 + Params.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public TransferInfoBlock() { }
|
|
public TransferInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TransferID.FromBytes(bytes, i); i += 16;
|
|
ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SourceType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Priority = Utils.BytesToFloat(bytes, i); i += 4;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_params = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _params, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(ChannelType, bytes, i); i += 4;
|
|
Utils.IntToBytes(SourceType, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Priority, bytes, i); i += 4;
|
|
if(Params == null) { Console.WriteLine("Warning: Params is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Params.Length % 256);
|
|
bytes[i++] = (byte)((Params.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Params, 0, bytes, i, Params.Length); i += Params.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransferInfo --");
|
|
output.AppendLine(String.Format("TransferID: {0}", TransferID));
|
|
output.AppendLine(String.Format("ChannelType: {0}", ChannelType));
|
|
output.AppendLine(String.Format("SourceType: {0}", SourceType));
|
|
output.AppendLine(String.Format("Priority: {0}", Priority));
|
|
Helpers.FieldToString(output, Params, "Params");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TransferRequest; } }
|
|
public TransferInfoBlock TransferInfo;
|
|
|
|
public TransferRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 153;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
TransferInfo = new TransferInfoBlock();
|
|
}
|
|
|
|
public TransferRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TransferRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TransferInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TransferInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TransferRequest ---" + Environment.NewLine;
|
|
output += TransferInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransferInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TransferInfoBlock : PacketBlock
|
|
{
|
|
public UUID TransferID;
|
|
public int ChannelType;
|
|
public int TargetType;
|
|
public int Status;
|
|
public int Size;
|
|
private byte[] _params;
|
|
public byte[] Params
|
|
{
|
|
get { return _params; }
|
|
set
|
|
{
|
|
if (value == null) { _params = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _params = new byte[value.Length]; Buffer.BlockCopy(value, 0, _params, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 32;
|
|
if (Params != null) { length += 2 + Params.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public TransferInfoBlock() { }
|
|
public TransferInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TransferID.FromBytes(bytes, i); i += 16;
|
|
ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TargetType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Status = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Size = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_params = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _params, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(ChannelType, bytes, i); i += 4;
|
|
Utils.IntToBytes(TargetType, bytes, i); i += 4;
|
|
Utils.IntToBytes(Status, bytes, i); i += 4;
|
|
Utils.IntToBytes(Size, bytes, i); i += 4;
|
|
if(Params == null) { Console.WriteLine("Warning: Params is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Params.Length % 256);
|
|
bytes[i++] = (byte)((Params.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Params, 0, bytes, i, Params.Length); i += Params.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransferInfo --");
|
|
output.AppendLine(String.Format("TransferID: {0}", TransferID));
|
|
output.AppendLine(String.Format("ChannelType: {0}", ChannelType));
|
|
output.AppendLine(String.Format("TargetType: {0}", TargetType));
|
|
output.AppendLine(String.Format("Status: {0}", Status));
|
|
output.AppendLine(String.Format("Size: {0}", Size));
|
|
Helpers.FieldToString(output, Params, "Params");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TransferInfo; } }
|
|
public TransferInfoBlock TransferInfo;
|
|
|
|
public TransferInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 154;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
TransferInfo = new TransferInfoBlock();
|
|
}
|
|
|
|
public TransferInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TransferInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TransferInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TransferInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TransferInfo ---" + Environment.NewLine;
|
|
output += TransferInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransferAbortPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TransferInfoBlock : PacketBlock
|
|
{
|
|
public UUID TransferID;
|
|
public int ChannelType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public TransferInfoBlock() { }
|
|
public TransferInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransferID.FromBytes(bytes, i); i += 16;
|
|
ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(ChannelType, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransferInfo --");
|
|
output.AppendLine(String.Format("TransferID: {0}", TransferID));
|
|
output.Append(String.Format("ChannelType: {0}", ChannelType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TransferAbort; } }
|
|
public TransferInfoBlock TransferInfo;
|
|
|
|
public TransferAbortPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 155;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
TransferInfo = new TransferInfoBlock();
|
|
}
|
|
|
|
public TransferAbortPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TransferAbortPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TransferInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TransferInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TransferAbort ---" + Environment.NewLine;
|
|
output += TransferInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestXferPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class XferIDBlock : PacketBlock
|
|
{
|
|
public ulong ID;
|
|
private byte[] _filename;
|
|
public byte[] Filename
|
|
{
|
|
get { return _filename; }
|
|
set
|
|
{
|
|
if (value == null) { _filename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte FilePath;
|
|
public bool DeleteOnCompletion;
|
|
public bool UseBigPackets;
|
|
public UUID VFileID;
|
|
public short VFileType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 29;
|
|
if (Filename != null) { length += 1 + Filename.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public XferIDBlock() { }
|
|
public XferIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
length = (ushort)bytes[i++];
|
|
_filename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
|
|
FilePath = (byte)bytes[i++];
|
|
DeleteOnCompletion = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
UseBigPackets = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
VFileID.FromBytes(bytes, i); i += 16;
|
|
VFileType = (short)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(ID, bytes, i); i += 8;
|
|
if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Filename.Length;
|
|
Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
|
|
bytes[i++] = FilePath;
|
|
bytes[i++] = (byte)((DeleteOnCompletion) ? 1 : 0);
|
|
bytes[i++] = (byte)((UseBigPackets) ? 1 : 0);
|
|
Buffer.BlockCopy(VFileID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)(VFileType % 256);
|
|
bytes[i++] = (byte)((VFileType >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- XferID --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
Helpers.FieldToString(output, Filename, "Filename");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("FilePath: {0}", FilePath));
|
|
output.AppendLine(String.Format("DeleteOnCompletion: {0}", DeleteOnCompletion));
|
|
output.AppendLine(String.Format("UseBigPackets: {0}", UseBigPackets));
|
|
output.AppendLine(String.Format("VFileID: {0}", VFileID));
|
|
output.Append(String.Format("VFileType: {0}", VFileType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestXfer; } }
|
|
public XferIDBlock XferID;
|
|
|
|
public RequestXferPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 156;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
XferID = new XferIDBlock();
|
|
}
|
|
|
|
public RequestXferPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestXferPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += XferID.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
XferID.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestXfer ---" + Environment.NewLine;
|
|
output += XferID.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AbortXferPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class XferIDBlock : PacketBlock
|
|
{
|
|
public ulong ID;
|
|
public int Result;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public XferIDBlock() { }
|
|
public XferIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Result = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(ID, bytes, i); i += 8;
|
|
Utils.IntToBytes(Result, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- XferID --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.Append(String.Format("Result: {0}", Result));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AbortXfer; } }
|
|
public XferIDBlock XferID;
|
|
|
|
public AbortXferPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 157;
|
|
Header.Reliable = true;
|
|
XferID = new XferIDBlock();
|
|
}
|
|
|
|
public AbortXferPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AbortXferPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += XferID.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
XferID.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AbortXfer ---" + Environment.NewLine;
|
|
output += XferID.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarAppearancePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class SenderBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public bool IsTrial;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public SenderBlock() { }
|
|
public SenderBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
IsTrial = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsTrial) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Sender --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.Append(String.Format("IsTrial: {0}", IsTrial));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
private byte[] _textureentry;
|
|
public byte[] TextureEntry
|
|
{
|
|
get { return _textureentry; }
|
|
set
|
|
{
|
|
if (value == null) { _textureentry = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_textureentry = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(TextureEntry.Length % 256);
|
|
bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
|
|
Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
Helpers.FieldToString(output, TextureEntry, "TextureEntry");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class VisualParamBlock : PacketBlock
|
|
{
|
|
public byte ParamValue;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public VisualParamBlock() { }
|
|
public VisualParamBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ParamValue = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = ParamValue;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- VisualParam --");
|
|
output.Append(String.Format("ParamValue: {0}", ParamValue));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarAppearance; } }
|
|
public SenderBlock Sender;
|
|
public ObjectDataBlock ObjectData;
|
|
public VisualParamBlock[] VisualParam;
|
|
|
|
public AvatarAppearancePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 158;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Sender = new SenderBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
VisualParam = new VisualParamBlock[0];
|
|
}
|
|
|
|
public AvatarAppearancePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Sender.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(VisualParam.Length < count) {
|
|
VisualParam = new VisualParamBlock[count];
|
|
for(int j = 0; j < count; j++) VisualParam[j] = new VisualParamBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VisualParam[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AvatarAppearancePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Sender.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(VisualParam.Length < count) {
|
|
VisualParam = new VisualParamBlock[count];
|
|
for(int j = 0; j < count; j++) VisualParam[j] = new VisualParamBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VisualParam[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Sender.Length; length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Sender.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)VisualParam.Length;
|
|
for (int j = 0; j < VisualParam.Length; j++) { VisualParam[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarAppearance ---" + Environment.NewLine;
|
|
output += Sender.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < VisualParam.Length; j++)
|
|
{
|
|
output += VisualParam[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SetFollowCamPropertiesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CameraPropertyBlock : PacketBlock
|
|
{
|
|
public int Type;
|
|
public float Value;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public CameraPropertyBlock() { }
|
|
public CameraPropertyBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Value = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(Type, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Value, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- CameraProperty --");
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.Append(String.Format("Value: {0}", Value));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SetFollowCamProperties; } }
|
|
public ObjectDataBlock ObjectData;
|
|
public CameraPropertyBlock[] CameraProperty;
|
|
|
|
public SetFollowCamPropertiesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 159;
|
|
Header.Reliable = true;
|
|
ObjectData = new ObjectDataBlock();
|
|
CameraProperty = new CameraPropertyBlock[0];
|
|
}
|
|
|
|
public SetFollowCamPropertiesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(CameraProperty.Length < count) {
|
|
CameraProperty = new CameraPropertyBlock[count];
|
|
for(int j = 0; j < count; j++) CameraProperty[j] = new CameraPropertyBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ CameraProperty[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public SetFollowCamPropertiesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(CameraProperty.Length < count) {
|
|
CameraProperty = new CameraPropertyBlock[count];
|
|
for(int j = 0; j < count; j++) CameraProperty[j] = new CameraPropertyBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ CameraProperty[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < CameraProperty.Length; j++) { length += CameraProperty[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)CameraProperty.Length;
|
|
for (int j = 0; j < CameraProperty.Length; j++) { CameraProperty[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SetFollowCamProperties ---" + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < CameraProperty.Length; j++)
|
|
{
|
|
output += CameraProperty[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ClearFollowCamPropertiesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ClearFollowCamProperties; } }
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public ClearFollowCamPropertiesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 160;
|
|
Header.Reliable = true;
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public ClearFollowCamPropertiesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ClearFollowCamPropertiesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ClearFollowCamProperties ---" + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestPayPricePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestPayPrice; } }
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public RequestPayPricePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 161;
|
|
Header.Reliable = true;
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public RequestPayPricePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestPayPricePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestPayPrice ---" + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PayPriceReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public int DefaultPayPrice;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
DefaultPayPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(DefaultPayPrice, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("DefaultPayPrice: {0}", DefaultPayPrice));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ButtonDataBlock : PacketBlock
|
|
{
|
|
public int PayButton;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ButtonDataBlock() { }
|
|
public ButtonDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PayButton = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(PayButton, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ButtonData --");
|
|
output.Append(String.Format("PayButton: {0}", PayButton));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PayPriceReply; } }
|
|
public ObjectDataBlock ObjectData;
|
|
public ButtonDataBlock[] ButtonData;
|
|
|
|
public PayPriceReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 162;
|
|
Header.Reliable = true;
|
|
ObjectData = new ObjectDataBlock();
|
|
ButtonData = new ButtonDataBlock[0];
|
|
}
|
|
|
|
public PayPriceReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ButtonData.Length < count) {
|
|
ButtonData = new ButtonDataBlock[count];
|
|
for(int j = 0; j < count; j++) ButtonData[j] = new ButtonDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ButtonData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public PayPriceReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ButtonData.Length < count) {
|
|
ButtonData = new ButtonDataBlock[count];
|
|
for(int j = 0; j < count; j++) ButtonData[j] = new ButtonDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ButtonData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ObjectData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ButtonData.Length; j++) { length += ButtonData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ButtonData.Length;
|
|
for (int j = 0; j < ButtonData.Length; j++) { ButtonData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PayPriceReply ---" + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ButtonData.Length; j++)
|
|
{
|
|
output += ButtonData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class KickUserPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TargetBlockBlock : PacketBlock
|
|
{
|
|
public uint TargetIP;
|
|
public ushort TargetPort;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
public TargetBlockBlock() { }
|
|
public TargetBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TargetPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(TargetIP, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((TargetPort >> 8) % 256);
|
|
bytes[i++] = (byte)(TargetPort % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TargetBlock --");
|
|
output.AppendLine(String.Format("TargetIP: {0}", TargetIP));
|
|
output.Append(String.Format("TargetPort: {0}", TargetPort));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UserInfoBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
private byte[] _reason;
|
|
public byte[] Reason
|
|
{
|
|
get { return _reason; }
|
|
set
|
|
{
|
|
if (value == null) { _reason = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _reason = new byte[value.Length]; Buffer.BlockCopy(value, 0, _reason, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 32;
|
|
if (Reason != null) { length += 2 + Reason.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public UserInfoBlock() { }
|
|
public UserInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_reason = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _reason, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Reason == null) { Console.WriteLine("Warning: Reason is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Reason.Length % 256);
|
|
bytes[i++] = (byte)((Reason.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Reason, 0, bytes, i, Reason.Length); i += Reason.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UserInfo --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
Helpers.FieldToString(output, Reason, "Reason");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.KickUser; } }
|
|
public TargetBlockBlock TargetBlock;
|
|
public UserInfoBlock UserInfo;
|
|
|
|
public KickUserPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 163;
|
|
Header.Reliable = true;
|
|
TargetBlock = new TargetBlockBlock();
|
|
UserInfo = new UserInfoBlock();
|
|
}
|
|
|
|
public KickUserPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TargetBlock.FromBytes(bytes, ref i);
|
|
UserInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public KickUserPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TargetBlock.FromBytes(bytes, ref i);
|
|
UserInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TargetBlock.Length; length += UserInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TargetBlock.ToBytes(bytes, ref i);
|
|
UserInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- KickUser ---" + Environment.NewLine;
|
|
output += TargetBlock.ToString() + Environment.NewLine;
|
|
output += UserInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class KickUserAckPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class UserInfoBlock : PacketBlock
|
|
{
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public UserInfoBlock() { }
|
|
public UserInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UserInfo --");
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.KickUserAck; } }
|
|
public UserInfoBlock UserInfo;
|
|
|
|
public KickUserAckPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 164;
|
|
Header.Reliable = true;
|
|
UserInfo = new UserInfoBlock();
|
|
}
|
|
|
|
public KickUserAckPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
UserInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public KickUserAckPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
UserInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += UserInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
UserInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- KickUserAck ---" + Environment.NewLine;
|
|
output += UserInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GodKickUserPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class UserInfoBlock : PacketBlock
|
|
{
|
|
public UUID GodID;
|
|
public UUID GodSessionID;
|
|
public UUID AgentID;
|
|
public uint KickFlags;
|
|
private byte[] _reason;
|
|
public byte[] Reason
|
|
{
|
|
get { return _reason; }
|
|
set
|
|
{
|
|
if (value == null) { _reason = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _reason = new byte[value.Length]; Buffer.BlockCopy(value, 0, _reason, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 52;
|
|
if (Reason != null) { length += 2 + Reason.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public UserInfoBlock() { }
|
|
public UserInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GodID.FromBytes(bytes, i); i += 16;
|
|
GodSessionID.FromBytes(bytes, i); i += 16;
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
KickFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_reason = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _reason, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GodID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GodSessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(KickFlags, bytes, i); i += 4;
|
|
if(Reason == null) { Console.WriteLine("Warning: Reason is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Reason.Length % 256);
|
|
bytes[i++] = (byte)((Reason.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Reason, 0, bytes, i, Reason.Length); i += Reason.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UserInfo --");
|
|
output.AppendLine(String.Format("GodID: {0}", GodID));
|
|
output.AppendLine(String.Format("GodSessionID: {0}", GodSessionID));
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("KickFlags: {0}", KickFlags));
|
|
Helpers.FieldToString(output, Reason, "Reason");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GodKickUser; } }
|
|
public UserInfoBlock UserInfo;
|
|
|
|
public GodKickUserPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 165;
|
|
Header.Reliable = true;
|
|
UserInfo = new UserInfoBlock();
|
|
}
|
|
|
|
public GodKickUserPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
UserInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GodKickUserPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
UserInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += UserInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
UserInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GodKickUser ---" + Environment.NewLine;
|
|
output += UserInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EjectUserPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TargetID: {0}", TargetID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EjectUser; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public EjectUserPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 167;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public EjectUserPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EjectUserPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EjectUser ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FreezeUserPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TargetID: {0}", TargetID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.FreezeUser; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public FreezeUserPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 168;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public FreezeUserPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public FreezeUserPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- FreezeUser ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarPropertiesRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID AvatarID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
AvatarID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("AvatarID: {0}", AvatarID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarPropertiesRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AvatarPropertiesRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 169;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AvatarPropertiesRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarPropertiesRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarPropertiesRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarPropertiesReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID AvatarID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
AvatarID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("AvatarID: {0}", AvatarID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PropertiesDataBlock : PacketBlock
|
|
{
|
|
public UUID ImageID;
|
|
public UUID FLImageID;
|
|
public UUID PartnerID;
|
|
private byte[] _abouttext;
|
|
public byte[] AboutText
|
|
{
|
|
get { return _abouttext; }
|
|
set
|
|
{
|
|
if (value == null) { _abouttext = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _abouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _abouttext, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _flabouttext;
|
|
public byte[] FLAboutText
|
|
{
|
|
get { return _flabouttext; }
|
|
set
|
|
{
|
|
if (value == null) { _flabouttext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _flabouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _flabouttext, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _bornon;
|
|
public byte[] BornOn
|
|
{
|
|
get { return _bornon; }
|
|
set
|
|
{
|
|
if (value == null) { _bornon = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _bornon = new byte[value.Length]; Buffer.BlockCopy(value, 0, _bornon, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _profileurl;
|
|
public byte[] ProfileURL
|
|
{
|
|
get { return _profileurl; }
|
|
set
|
|
{
|
|
if (value == null) { _profileurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _profileurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _profileurl, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _chartermember;
|
|
public byte[] CharterMember
|
|
{
|
|
get { return _chartermember; }
|
|
set
|
|
{
|
|
if (value == null) { _chartermember = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _chartermember = new byte[value.Length]; Buffer.BlockCopy(value, 0, _chartermember, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 52;
|
|
if (AboutText != null) { length += 2 + AboutText.Length; }
|
|
if (FLAboutText != null) { length += 1 + FLAboutText.Length; }
|
|
if (BornOn != null) { length += 1 + BornOn.Length; }
|
|
if (ProfileURL != null) { length += 1 + ProfileURL.Length; }
|
|
if (CharterMember != null) { length += 1 + CharterMember.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public PropertiesDataBlock() { }
|
|
public PropertiesDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ImageID.FromBytes(bytes, i); i += 16;
|
|
FLImageID.FromBytes(bytes, i); i += 16;
|
|
PartnerID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_abouttext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _abouttext, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_flabouttext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _flabouttext, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_bornon = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _bornon, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_profileurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _profileurl, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_chartermember = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _chartermember, 0, length); i += length;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FLImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(PartnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(AboutText == null) { Console.WriteLine("Warning: AboutText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(AboutText.Length % 256);
|
|
bytes[i++] = (byte)((AboutText.Length >> 8) % 256);
|
|
Buffer.BlockCopy(AboutText, 0, bytes, i, AboutText.Length); i += AboutText.Length;
|
|
if(FLAboutText == null) { Console.WriteLine("Warning: FLAboutText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FLAboutText.Length;
|
|
Buffer.BlockCopy(FLAboutText, 0, bytes, i, FLAboutText.Length); i += FLAboutText.Length;
|
|
if(BornOn == null) { Console.WriteLine("Warning: BornOn is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)BornOn.Length;
|
|
Buffer.BlockCopy(BornOn, 0, bytes, i, BornOn.Length); i += BornOn.Length;
|
|
if(ProfileURL == null) { Console.WriteLine("Warning: ProfileURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ProfileURL.Length;
|
|
Buffer.BlockCopy(ProfileURL, 0, bytes, i, ProfileURL.Length); i += ProfileURL.Length;
|
|
if(CharterMember == null) { Console.WriteLine("Warning: CharterMember is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)CharterMember.Length;
|
|
Buffer.BlockCopy(CharterMember, 0, bytes, i, CharterMember.Length); i += CharterMember.Length;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PropertiesData --");
|
|
output.AppendLine(String.Format("ImageID: {0}", ImageID));
|
|
output.AppendLine(String.Format("FLImageID: {0}", FLImageID));
|
|
output.AppendLine(String.Format("PartnerID: {0}", PartnerID));
|
|
Helpers.FieldToString(output, AboutText, "AboutText");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, FLAboutText, "FLAboutText");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, BornOn, "BornOn");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, ProfileURL, "ProfileURL");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, CharterMember, "CharterMember");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarPropertiesReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public PropertiesDataBlock PropertiesData;
|
|
|
|
public AvatarPropertiesReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 171;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
PropertiesData = new PropertiesDataBlock();
|
|
}
|
|
|
|
public AvatarPropertiesReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarPropertiesReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += PropertiesData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
PropertiesData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarPropertiesReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += PropertiesData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarInterestsReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID AvatarID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
AvatarID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("AvatarID: {0}", AvatarID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PropertiesDataBlock : PacketBlock
|
|
{
|
|
public uint WantToMask;
|
|
private byte[] _wanttotext;
|
|
public byte[] WantToText
|
|
{
|
|
get { return _wanttotext; }
|
|
set
|
|
{
|
|
if (value == null) { _wanttotext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _wanttotext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _wanttotext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint SkillsMask;
|
|
private byte[] _skillstext;
|
|
public byte[] SkillsText
|
|
{
|
|
get { return _skillstext; }
|
|
set
|
|
{
|
|
if (value == null) { _skillstext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _skillstext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _skillstext, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _languagestext;
|
|
public byte[] LanguagesText
|
|
{
|
|
get { return _languagestext; }
|
|
set
|
|
{
|
|
if (value == null) { _languagestext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _languagestext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _languagestext, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 8;
|
|
if (WantToText != null) { length += 1 + WantToText.Length; }
|
|
if (SkillsText != null) { length += 1 + SkillsText.Length; }
|
|
if (LanguagesText != null) { length += 1 + LanguagesText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public PropertiesDataBlock() { }
|
|
public PropertiesDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
WantToMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_wanttotext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _wanttotext, 0, length); i += length;
|
|
SkillsMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_skillstext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _skillstext, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_languagestext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _languagestext, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(WantToMask, bytes, i); i += 4;
|
|
if(WantToText == null) { Console.WriteLine("Warning: WantToText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)WantToText.Length;
|
|
Buffer.BlockCopy(WantToText, 0, bytes, i, WantToText.Length); i += WantToText.Length;
|
|
Utils.UIntToBytes(SkillsMask, bytes, i); i += 4;
|
|
if(SkillsText == null) { Console.WriteLine("Warning: SkillsText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SkillsText.Length;
|
|
Buffer.BlockCopy(SkillsText, 0, bytes, i, SkillsText.Length); i += SkillsText.Length;
|
|
if(LanguagesText == null) { Console.WriteLine("Warning: LanguagesText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LanguagesText.Length;
|
|
Buffer.BlockCopy(LanguagesText, 0, bytes, i, LanguagesText.Length); i += LanguagesText.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PropertiesData --");
|
|
output.AppendLine(String.Format("WantToMask: {0}", WantToMask));
|
|
Helpers.FieldToString(output, WantToText, "WantToText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SkillsMask: {0}", SkillsMask));
|
|
Helpers.FieldToString(output, SkillsText, "SkillsText");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LanguagesText, "LanguagesText");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarInterestsReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public PropertiesDataBlock PropertiesData;
|
|
|
|
public AvatarInterestsReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 172;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
PropertiesData = new PropertiesDataBlock();
|
|
}
|
|
|
|
public AvatarInterestsReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarInterestsReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += PropertiesData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
PropertiesData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarInterestsReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += PropertiesData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarGroupsReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID AvatarID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
AvatarID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AvatarID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("AvatarID: {0}", AvatarID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public ulong GroupPowers;
|
|
public bool AcceptNotices;
|
|
private byte[] _grouptitle;
|
|
public byte[] GroupTitle
|
|
{
|
|
get { return _grouptitle; }
|
|
set
|
|
{
|
|
if (value == null) { _grouptitle = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _grouptitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _grouptitle, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID GroupID;
|
|
private byte[] _groupname;
|
|
public byte[] GroupName
|
|
{
|
|
get { return _groupname; }
|
|
set
|
|
{
|
|
if (value == null) { _groupname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID GroupInsigniaID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 41;
|
|
if (GroupTitle != null) { length += 1 + GroupTitle.Length; }
|
|
if (GroupName != null) { length += 1 + GroupName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_grouptitle = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _grouptitle, 0, length); i += length;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_groupname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
|
|
GroupInsigniaID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(GroupPowers, bytes, i); i += 8;
|
|
bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
|
|
if(GroupTitle == null) { Console.WriteLine("Warning: GroupTitle is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupTitle.Length;
|
|
Buffer.BlockCopy(GroupTitle, 0, bytes, i, GroupTitle.Length); i += GroupTitle.Length;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupName.Length;
|
|
Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
|
|
Buffer.BlockCopy(GroupInsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
|
|
output.AppendLine(String.Format("AcceptNotices: {0}", AcceptNotices));
|
|
Helpers.FieldToString(output, GroupTitle, "GroupTitle");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
Helpers.FieldToString(output, GroupName, "GroupName");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("GroupInsigniaID: {0}", GroupInsigniaID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NewGroupDataBlock : PacketBlock
|
|
{
|
|
public bool ListInProfile;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public NewGroupDataBlock() { }
|
|
public NewGroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ListInProfile = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((ListInProfile) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NewGroupData --");
|
|
output.Append(String.Format("ListInProfile: {0}", ListInProfile));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarGroupsReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock[] GroupData;
|
|
public NewGroupDataBlock NewGroupData;
|
|
|
|
public AvatarGroupsReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 173;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock[0];
|
|
NewGroupData = new NewGroupDataBlock();
|
|
}
|
|
|
|
public AvatarGroupsReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
NewGroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarGroupsReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
NewGroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += NewGroupData.Length;;
|
|
length++;
|
|
for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)GroupData.Length;
|
|
for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
|
|
NewGroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarGroupsReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < GroupData.Length; j++)
|
|
{
|
|
output += GroupData[j].ToString() + Environment.NewLine;
|
|
}
|
|
output += NewGroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarPropertiesUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PropertiesDataBlock : PacketBlock
|
|
{
|
|
public UUID ImageID;
|
|
public UUID FLImageID;
|
|
private byte[] _abouttext;
|
|
public byte[] AboutText
|
|
{
|
|
get { return _abouttext; }
|
|
set
|
|
{
|
|
if (value == null) { _abouttext = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _abouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _abouttext, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _flabouttext;
|
|
public byte[] FLAboutText
|
|
{
|
|
get { return _flabouttext; }
|
|
set
|
|
{
|
|
if (value == null) { _flabouttext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _flabouttext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _flabouttext, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool AllowPublish;
|
|
public bool MaturePublish;
|
|
private byte[] _profileurl;
|
|
public byte[] ProfileURL
|
|
{
|
|
get { return _profileurl; }
|
|
set
|
|
{
|
|
if (value == null) { _profileurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _profileurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _profileurl, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 34;
|
|
if (AboutText != null) { length += 2 + AboutText.Length; }
|
|
if (FLAboutText != null) { length += 1 + FLAboutText.Length; }
|
|
if (ProfileURL != null) { length += 1 + ProfileURL.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public PropertiesDataBlock() { }
|
|
public PropertiesDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ImageID.FromBytes(bytes, i); i += 16;
|
|
FLImageID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_abouttext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _abouttext, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_flabouttext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _flabouttext, 0, length); i += length;
|
|
AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_profileurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _profileurl, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FLImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(AboutText == null) { Console.WriteLine("Warning: AboutText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(AboutText.Length % 256);
|
|
bytes[i++] = (byte)((AboutText.Length >> 8) % 256);
|
|
Buffer.BlockCopy(AboutText, 0, bytes, i, AboutText.Length); i += AboutText.Length;
|
|
if(FLAboutText == null) { Console.WriteLine("Warning: FLAboutText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FLAboutText.Length;
|
|
Buffer.BlockCopy(FLAboutText, 0, bytes, i, FLAboutText.Length); i += FLAboutText.Length;
|
|
bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
|
|
bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
|
|
if(ProfileURL == null) { Console.WriteLine("Warning: ProfileURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ProfileURL.Length;
|
|
Buffer.BlockCopy(ProfileURL, 0, bytes, i, ProfileURL.Length); i += ProfileURL.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PropertiesData --");
|
|
output.AppendLine(String.Format("ImageID: {0}", ImageID));
|
|
output.AppendLine(String.Format("FLImageID: {0}", FLImageID));
|
|
Helpers.FieldToString(output, AboutText, "AboutText");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, FLAboutText, "FLAboutText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
|
|
output.AppendLine(String.Format("MaturePublish: {0}", MaturePublish));
|
|
Helpers.FieldToString(output, ProfileURL, "ProfileURL");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarPropertiesUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public PropertiesDataBlock PropertiesData;
|
|
|
|
public AvatarPropertiesUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 174;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
PropertiesData = new PropertiesDataBlock();
|
|
}
|
|
|
|
public AvatarPropertiesUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarPropertiesUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += PropertiesData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
PropertiesData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarPropertiesUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += PropertiesData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarInterestsUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PropertiesDataBlock : PacketBlock
|
|
{
|
|
public uint WantToMask;
|
|
private byte[] _wanttotext;
|
|
public byte[] WantToText
|
|
{
|
|
get { return _wanttotext; }
|
|
set
|
|
{
|
|
if (value == null) { _wanttotext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _wanttotext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _wanttotext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint SkillsMask;
|
|
private byte[] _skillstext;
|
|
public byte[] SkillsText
|
|
{
|
|
get { return _skillstext; }
|
|
set
|
|
{
|
|
if (value == null) { _skillstext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _skillstext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _skillstext, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _languagestext;
|
|
public byte[] LanguagesText
|
|
{
|
|
get { return _languagestext; }
|
|
set
|
|
{
|
|
if (value == null) { _languagestext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _languagestext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _languagestext, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 8;
|
|
if (WantToText != null) { length += 1 + WantToText.Length; }
|
|
if (SkillsText != null) { length += 1 + SkillsText.Length; }
|
|
if (LanguagesText != null) { length += 1 + LanguagesText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public PropertiesDataBlock() { }
|
|
public PropertiesDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
WantToMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_wanttotext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _wanttotext, 0, length); i += length;
|
|
SkillsMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_skillstext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _skillstext, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_languagestext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _languagestext, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(WantToMask, bytes, i); i += 4;
|
|
if(WantToText == null) { Console.WriteLine("Warning: WantToText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)WantToText.Length;
|
|
Buffer.BlockCopy(WantToText, 0, bytes, i, WantToText.Length); i += WantToText.Length;
|
|
Utils.UIntToBytes(SkillsMask, bytes, i); i += 4;
|
|
if(SkillsText == null) { Console.WriteLine("Warning: SkillsText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SkillsText.Length;
|
|
Buffer.BlockCopy(SkillsText, 0, bytes, i, SkillsText.Length); i += SkillsText.Length;
|
|
if(LanguagesText == null) { Console.WriteLine("Warning: LanguagesText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LanguagesText.Length;
|
|
Buffer.BlockCopy(LanguagesText, 0, bytes, i, LanguagesText.Length); i += LanguagesText.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PropertiesData --");
|
|
output.AppendLine(String.Format("WantToMask: {0}", WantToMask));
|
|
Helpers.FieldToString(output, WantToText, "WantToText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SkillsMask: {0}", SkillsMask));
|
|
Helpers.FieldToString(output, SkillsText, "SkillsText");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LanguagesText, "LanguagesText");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarInterestsUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public PropertiesDataBlock PropertiesData;
|
|
|
|
public AvatarInterestsUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 175;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
PropertiesData = new PropertiesDataBlock();
|
|
}
|
|
|
|
public AvatarInterestsUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarInterestsUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PropertiesData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += PropertiesData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
PropertiesData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarInterestsUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += PropertiesData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarNotesReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
private byte[] _notes;
|
|
public byte[] Notes
|
|
{
|
|
get { return _notes; }
|
|
set
|
|
{
|
|
if (value == null) { _notes = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _notes = new byte[value.Length]; Buffer.BlockCopy(value, 0, _notes, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Notes != null) { length += 2 + Notes.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_notes = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _notes, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Notes == null) { Console.WriteLine("Warning: Notes is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Notes.Length % 256);
|
|
bytes[i++] = (byte)((Notes.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Notes, 0, bytes, i, Notes.Length); i += Notes.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TargetID: {0}", TargetID));
|
|
Helpers.FieldToString(output, Notes, "Notes");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarNotesReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public AvatarNotesReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 176;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public AvatarNotesReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarNotesReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarNotesReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarNotesUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
private byte[] _notes;
|
|
public byte[] Notes
|
|
{
|
|
get { return _notes; }
|
|
set
|
|
{
|
|
if (value == null) { _notes = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _notes = new byte[value.Length]; Buffer.BlockCopy(value, 0, _notes, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Notes != null) { length += 2 + Notes.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_notes = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _notes, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Notes == null) { Console.WriteLine("Warning: Notes is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Notes.Length % 256);
|
|
bytes[i++] = (byte)((Notes.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Notes, 0, bytes, i, Notes.Length); i += Notes.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TargetID: {0}", TargetID));
|
|
Helpers.FieldToString(output, Notes, "Notes");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarNotesUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public AvatarNotesUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 177;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public AvatarNotesUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarNotesUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarNotesUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarPicksReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID TargetID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("TargetID: {0}", TargetID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID PickID;
|
|
private byte[] _pickname;
|
|
public byte[] PickName
|
|
{
|
|
get { return _pickname; }
|
|
set
|
|
{
|
|
if (value == null) { _pickname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _pickname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _pickname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (PickName != null) { length += 1 + PickName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
PickID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_pickname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _pickname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(PickName == null) { Console.WriteLine("Warning: PickName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)PickName.Length;
|
|
Buffer.BlockCopy(PickName, 0, bytes, i, PickName.Length); i += PickName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("PickID: {0}", PickID));
|
|
Helpers.FieldToString(output, PickName, "PickName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarPicksReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public AvatarPicksReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 178;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public AvatarPicksReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AvatarPicksReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarPicksReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventInfoRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventDataBlock : PacketBlock
|
|
{
|
|
public uint EventID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public EventDataBlock() { }
|
|
public EventDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EventData --");
|
|
output.Append(String.Format("EventID: {0}", EventID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EventInfoRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public EventDataBlock EventData;
|
|
|
|
public EventInfoRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 179;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
EventData = new EventDataBlock();
|
|
}
|
|
|
|
public EventInfoRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EventInfoRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += EventData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
EventData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EventInfoRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += EventData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventInfoReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventDataBlock : PacketBlock
|
|
{
|
|
public uint EventID;
|
|
private byte[] _creator;
|
|
public byte[] Creator
|
|
{
|
|
get { return _creator; }
|
|
set
|
|
{
|
|
if (value == null) { _creator = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _creator = new byte[value.Length]; Buffer.BlockCopy(value, 0, _creator, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _category;
|
|
public byte[] Category
|
|
{
|
|
get { return _category; }
|
|
set
|
|
{
|
|
if (value == null) { _category = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _category = new byte[value.Length]; Buffer.BlockCopy(value, 0, _category, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _date;
|
|
public byte[] Date
|
|
{
|
|
get { return _date; }
|
|
set
|
|
{
|
|
if (value == null) { _date = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _date = new byte[value.Length]; Buffer.BlockCopy(value, 0, _date, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint DateUTC;
|
|
public uint Duration;
|
|
public uint Cover;
|
|
public uint Amount;
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public Vector3d GlobalPos;
|
|
public uint EventFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 48;
|
|
if (Creator != null) { length += 1 + Creator.Length; }
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Category != null) { length += 1 + Category.Length; }
|
|
if (Desc != null) { length += 2 + Desc.Length; }
|
|
if (Date != null) { length += 1 + Date.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public EventDataBlock() { }
|
|
public EventDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_creator = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _creator, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_category = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _category, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_date = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _date, 0, length); i += length;
|
|
DateUTC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Duration = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Cover = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Amount = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
GlobalPos.FromBytes(bytes, i); i += 24;
|
|
EventFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
if(Creator == null) { Console.WriteLine("Warning: Creator is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Creator.Length;
|
|
Buffer.BlockCopy(Creator, 0, bytes, i, Creator.Length); i += Creator.Length;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Category == null) { Console.WriteLine("Warning: Category is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Category.Length;
|
|
Buffer.BlockCopy(Category, 0, bytes, i, Category.Length); i += Category.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Desc.Length % 256);
|
|
bytes[i++] = (byte)((Desc.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
if(Date == null) { Console.WriteLine("Warning: Date is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Date.Length;
|
|
Buffer.BlockCopy(Date, 0, bytes, i, Date.Length); i += Date.Length;
|
|
Utils.UIntToBytes(DateUTC, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Duration, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Cover, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Amount, bytes, i); i += 4;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(GlobalPos.GetBytes(), 0, bytes, i, 24); i += 24;
|
|
Utils.UIntToBytes(EventFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EventData --");
|
|
output.AppendLine(String.Format("EventID: {0}", EventID));
|
|
Helpers.FieldToString(output, Creator, "Creator");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Category, "Category");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Date, "Date");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("DateUTC: {0}", DateUTC));
|
|
output.AppendLine(String.Format("Duration: {0}", Duration));
|
|
output.AppendLine(String.Format("Cover: {0}", Cover));
|
|
output.AppendLine(String.Format("Amount: {0}", Amount));
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("GlobalPos: {0}", GlobalPos));
|
|
output.Append(String.Format("EventFlags: {0}", EventFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EventInfoReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public EventDataBlock EventData;
|
|
|
|
public EventInfoReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 180;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
EventData = new EventDataBlock();
|
|
}
|
|
|
|
public EventInfoReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EventInfoReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += EventData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
EventData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EventInfoReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += EventData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventNotificationAddRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventDataBlock : PacketBlock
|
|
{
|
|
public uint EventID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public EventDataBlock() { }
|
|
public EventDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EventData --");
|
|
output.Append(String.Format("EventID: {0}", EventID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EventNotificationAddRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public EventDataBlock EventData;
|
|
|
|
public EventNotificationAddRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 181;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
EventData = new EventDataBlock();
|
|
}
|
|
|
|
public EventNotificationAddRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EventNotificationAddRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += EventData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
EventData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EventNotificationAddRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += EventData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventNotificationRemoveRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventDataBlock : PacketBlock
|
|
{
|
|
public uint EventID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public EventDataBlock() { }
|
|
public EventDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EventData --");
|
|
output.Append(String.Format("EventID: {0}", EventID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EventNotificationRemoveRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public EventDataBlock EventData;
|
|
|
|
public EventNotificationRemoveRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 182;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
EventData = new EventDataBlock();
|
|
}
|
|
|
|
public EventNotificationRemoveRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EventNotificationRemoveRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += EventData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
EventData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EventNotificationRemoveRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += EventData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventGodDeletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventDataBlock : PacketBlock
|
|
{
|
|
public uint EventID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public EventDataBlock() { }
|
|
public EventDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EventData --");
|
|
output.Append(String.Format("EventID: {0}", EventID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
private byte[] _querytext;
|
|
public byte[] QueryText
|
|
{
|
|
get { return _querytext; }
|
|
set
|
|
{
|
|
if (value == null) { _querytext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _querytext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _querytext, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint QueryFlags;
|
|
public int QueryStart;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (QueryText != null) { length += 1 + QueryText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_querytext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _querytext, 0, length); i += length;
|
|
QueryFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
QueryStart = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(QueryText == null) { Console.WriteLine("Warning: QueryText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)QueryText.Length;
|
|
Buffer.BlockCopy(QueryText, 0, bytes, i, QueryText.Length); i += QueryText.Length;
|
|
Utils.UIntToBytes(QueryFlags, bytes, i); i += 4;
|
|
Utils.IntToBytes(QueryStart, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
Helpers.FieldToString(output, QueryText, "QueryText");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("QueryFlags: {0}", QueryFlags));
|
|
output.Append(String.Format("QueryStart: {0}", QueryStart));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EventGodDelete; } }
|
|
public AgentDataBlock AgentData;
|
|
public EventDataBlock EventData;
|
|
public QueryDataBlock QueryData;
|
|
|
|
public EventGodDeletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 183;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
EventData = new EventDataBlock();
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public EventGodDeletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EventGodDeletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += EventData.Length; length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
EventData.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EventGodDelete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += EventData.ToString() + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PickInfoReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID PickID;
|
|
public UUID CreatorID;
|
|
public bool TopPick;
|
|
public UUID ParcelID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID SnapshotID;
|
|
private byte[] _user;
|
|
public byte[] User
|
|
{
|
|
get { return _user; }
|
|
set
|
|
{
|
|
if (value == null) { _user = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _user = new byte[value.Length]; Buffer.BlockCopy(value, 0, _user, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _originalname;
|
|
public byte[] OriginalName
|
|
{
|
|
get { return _originalname; }
|
|
set
|
|
{
|
|
if (value == null) { _originalname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _originalname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _originalname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public Vector3d PosGlobal;
|
|
public int SortOrder;
|
|
public bool Enabled;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 94;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 2 + Desc.Length; }
|
|
if (User != null) { length += 1 + User.Length; }
|
|
if (OriginalName != null) { length += 1 + OriginalName.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
PickID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
TopPick = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_user = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _user, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_originalname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _originalname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
PosGlobal.FromBytes(bytes, i); i += 24;
|
|
SortOrder = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Enabled = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((TopPick) ? 1 : 0);
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Desc.Length % 256);
|
|
bytes[i++] = (byte)((Desc.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(User == null) { Console.WriteLine("Warning: User is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)User.Length;
|
|
Buffer.BlockCopy(User, 0, bytes, i, User.Length); i += User.Length;
|
|
if(OriginalName == null) { Console.WriteLine("Warning: OriginalName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)OriginalName.Length;
|
|
Buffer.BlockCopy(OriginalName, 0, bytes, i, OriginalName.Length); i += OriginalName.Length;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
|
|
Utils.IntToBytes(SortOrder, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Enabled) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("PickID: {0}", PickID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("TopPick: {0}", TopPick));
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
Helpers.FieldToString(output, User, "User");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, OriginalName, "OriginalName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
|
|
output.AppendLine(String.Format("SortOrder: {0}", SortOrder));
|
|
output.Append(String.Format("Enabled: {0}", Enabled));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PickInfoReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public PickInfoReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 184;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public PickInfoReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public PickInfoReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PickInfoReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PickInfoUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID PickID;
|
|
public UUID CreatorID;
|
|
public bool TopPick;
|
|
public UUID ParcelID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID SnapshotID;
|
|
public Vector3d PosGlobal;
|
|
public int SortOrder;
|
|
public bool Enabled;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 94;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 2 + Desc.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
PickID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
TopPick = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
PosGlobal.FromBytes(bytes, i); i += 24;
|
|
SortOrder = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Enabled = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((TopPick) ? 1 : 0);
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Desc.Length % 256);
|
|
bytes[i++] = (byte)((Desc.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
|
|
Utils.IntToBytes(SortOrder, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Enabled) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("PickID: {0}", PickID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("TopPick: {0}", TopPick));
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
|
|
output.AppendLine(String.Format("SortOrder: {0}", SortOrder));
|
|
output.Append(String.Format("Enabled: {0}", Enabled));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PickInfoUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public PickInfoUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 185;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public PickInfoUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public PickInfoUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PickInfoUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PickDeletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID PickID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PickID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("PickID: {0}", PickID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PickDelete; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public PickDeletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 186;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public PickDeletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public PickDeletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PickDelete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PickGodDeletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID PickID;
|
|
public UUID QueryID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PickID.FromBytes(bytes, i); i += 16;
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(PickID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("PickID: {0}", PickID));
|
|
output.Append(String.Format("QueryID: {0}", QueryID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PickGodDelete; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public PickGodDeletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 187;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public PickGodDeletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public PickGodDeletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PickGodDelete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptQuestionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID TaskID;
|
|
public UUID ItemID;
|
|
private byte[] _objectname;
|
|
public byte[] ObjectName
|
|
{
|
|
get { return _objectname; }
|
|
set
|
|
{
|
|
if (value == null) { _objectname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _objectowner;
|
|
public byte[] ObjectOwner
|
|
{
|
|
get { return _objectowner; }
|
|
set
|
|
{
|
|
if (value == null) { _objectowner = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectowner = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectowner, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Questions;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 36;
|
|
if (ObjectName != null) { length += 1 + ObjectName.Length; }
|
|
if (ObjectOwner != null) { length += 1 + ObjectOwner.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TaskID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_objectname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_objectowner = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectowner, 0, length); i += length;
|
|
Questions = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectName.Length;
|
|
Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
|
|
if(ObjectOwner == null) { Console.WriteLine("Warning: ObjectOwner is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectOwner.Length;
|
|
Buffer.BlockCopy(ObjectOwner, 0, bytes, i, ObjectOwner.Length); i += ObjectOwner.Length;
|
|
Utils.IntToBytes(Questions, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TaskID: {0}", TaskID));
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
Helpers.FieldToString(output, ObjectName, "ObjectName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, ObjectOwner, "ObjectOwner");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Questions: {0}", Questions));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptQuestion; } }
|
|
public DataBlock Data;
|
|
|
|
public ScriptQuestionPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 188;
|
|
Header.Reliable = true;
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ScriptQuestionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptQuestionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptQuestion ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptControlChangePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public bool TakeControls;
|
|
public uint Controls;
|
|
public bool PassToAgent;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TakeControls = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Controls = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PassToAgent = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((TakeControls) ? 1 : 0);
|
|
Utils.UIntToBytes(Controls, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((PassToAgent) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("TakeControls: {0}", TakeControls));
|
|
output.AppendLine(String.Format("Controls: {0}", Controls));
|
|
output.Append(String.Format("PassToAgent: {0}", PassToAgent));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptControlChange; } }
|
|
public DataBlock[] Data;
|
|
|
|
public ScriptControlChangePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 189;
|
|
Header.Reliable = true;
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public ScriptControlChangePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ScriptControlChangePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptControlChange ---" + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptDialogPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
private byte[] _firstname;
|
|
public byte[] FirstName
|
|
{
|
|
get { return _firstname; }
|
|
set
|
|
{
|
|
if (value == null) { _firstname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _lastname;
|
|
public byte[] LastName
|
|
{
|
|
get { return _lastname; }
|
|
set
|
|
{
|
|
if (value == null) { _lastname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _objectname;
|
|
public byte[] ObjectName
|
|
{
|
|
get { return _objectname; }
|
|
set
|
|
{
|
|
if (value == null) { _objectname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
public int ChatChannel;
|
|
public UUID ImageID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 36;
|
|
if (FirstName != null) { length += 1 + FirstName.Length; }
|
|
if (LastName != null) { length += 1 + LastName.Length; }
|
|
if (ObjectName != null) { length += 1 + ObjectName.Length; }
|
|
if (Message != null) { length += 2 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_firstname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_lastname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_objectname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
ChatChannel = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ImageID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FirstName.Length;
|
|
Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
|
|
if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LastName.Length;
|
|
Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
|
|
if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectName.Length;
|
|
Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Message.Length % 256);
|
|
bytes[i++] = (byte)((Message.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
Utils.IntToBytes(ChatChannel, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
Helpers.FieldToString(output, FirstName, "FirstName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LastName, "LastName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, ObjectName, "ObjectName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ChatChannel: {0}", ChatChannel));
|
|
output.Append(String.Format("ImageID: {0}", ImageID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ButtonsBlock : PacketBlock
|
|
{
|
|
private byte[] _buttonlabel;
|
|
public byte[] ButtonLabel
|
|
{
|
|
get { return _buttonlabel; }
|
|
set
|
|
{
|
|
if (value == null) { _buttonlabel = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _buttonlabel = new byte[value.Length]; Buffer.BlockCopy(value, 0, _buttonlabel, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (ButtonLabel != null) { length += 1 + ButtonLabel.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ButtonsBlock() { }
|
|
public ButtonsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_buttonlabel = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _buttonlabel, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(ButtonLabel == null) { Console.WriteLine("Warning: ButtonLabel is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ButtonLabel.Length;
|
|
Buffer.BlockCopy(ButtonLabel, 0, bytes, i, ButtonLabel.Length); i += ButtonLabel.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Buttons --");
|
|
Helpers.FieldToString(output, ButtonLabel, "ButtonLabel");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptDialog; } }
|
|
public DataBlock Data;
|
|
public ButtonsBlock[] Buttons;
|
|
|
|
public ScriptDialogPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 190;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Data = new DataBlock();
|
|
Buttons = new ButtonsBlock[0];
|
|
}
|
|
|
|
public ScriptDialogPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Buttons.Length < count) {
|
|
Buttons = new ButtonsBlock[count];
|
|
for(int j = 0; j < count; j++) Buttons[j] = new ButtonsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Buttons[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ScriptDialogPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Buttons.Length < count) {
|
|
Buttons = new ButtonsBlock[count];
|
|
for(int j = 0; j < count; j++) Buttons[j] = new ButtonsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Buttons[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
length++;
|
|
for (int j = 0; j < Buttons.Length; j++) { length += Buttons[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Buttons.Length;
|
|
for (int j = 0; j < Buttons.Length; j++) { Buttons[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptDialog ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Buttons.Length; j++)
|
|
{
|
|
output += Buttons[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptDialogReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public int ChatChannel;
|
|
public int ButtonIndex;
|
|
private byte[] _buttonlabel;
|
|
public byte[] ButtonLabel
|
|
{
|
|
get { return _buttonlabel; }
|
|
set
|
|
{
|
|
if (value == null) { _buttonlabel = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _buttonlabel = new byte[value.Length]; Buffer.BlockCopy(value, 0, _buttonlabel, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (ButtonLabel != null) { length += 1 + ButtonLabel.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ChatChannel = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ButtonIndex = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_buttonlabel = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _buttonlabel, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(ChatChannel, bytes, i); i += 4;
|
|
Utils.IntToBytes(ButtonIndex, bytes, i); i += 4;
|
|
if(ButtonLabel == null) { Console.WriteLine("Warning: ButtonLabel is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ButtonLabel.Length;
|
|
Buffer.BlockCopy(ButtonLabel, 0, bytes, i, ButtonLabel.Length); i += ButtonLabel.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("ChatChannel: {0}", ChatChannel));
|
|
output.AppendLine(String.Format("ButtonIndex: {0}", ButtonIndex));
|
|
Helpers.FieldToString(output, ButtonLabel, "ButtonLabel");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptDialogReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ScriptDialogReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 191;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ScriptDialogReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptDialogReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptDialogReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ForceScriptControlReleasePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ForceScriptControlRelease; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ForceScriptControlReleasePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 192;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ForceScriptControlReleasePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ForceScriptControlReleasePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ForceScriptControlRelease ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RevokePermissionsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public uint ObjectPermissions;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ObjectPermissions = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(ObjectPermissions, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("ObjectPermissions: {0}", ObjectPermissions));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RevokePermissions; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public RevokePermissionsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 193;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public RevokePermissionsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RevokePermissionsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RevokePermissions ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LoadURLPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
private byte[] _objectname;
|
|
public byte[] ObjectName
|
|
{
|
|
get { return _objectname; }
|
|
set
|
|
{
|
|
if (value == null) { _objectname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID ObjectID;
|
|
public UUID OwnerID;
|
|
public bool OwnerIsGroup;
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _url;
|
|
public byte[] URL
|
|
{
|
|
get { return _url; }
|
|
set
|
|
{
|
|
if (value == null) { _url = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _url = new byte[value.Length]; Buffer.BlockCopy(value, 0, _url, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 33;
|
|
if (ObjectName != null) { length += 1 + ObjectName.Length; }
|
|
if (Message != null) { length += 1 + Message.Length; }
|
|
if (URL != null) { length += 1 + URL.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_objectname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
OwnerIsGroup = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_url = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _url, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectName.Length;
|
|
Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((OwnerIsGroup) ? 1 : 0);
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Message.Length;
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
if(URL == null) { Console.WriteLine("Warning: URL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)URL.Length;
|
|
Buffer.BlockCopy(URL, 0, bytes, i, URL.Length); i += URL.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
Helpers.FieldToString(output, ObjectName, "ObjectName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("OwnerIsGroup: {0}", OwnerIsGroup));
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, URL, "URL");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LoadURL; } }
|
|
public DataBlock Data;
|
|
|
|
public LoadURLPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 194;
|
|
Header.Reliable = true;
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public LoadURLPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LoadURLPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LoadURL ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptTeleportRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
private byte[] _objectname;
|
|
public byte[] ObjectName
|
|
{
|
|
get { return _objectname; }
|
|
set
|
|
{
|
|
if (value == null) { _objectname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public Vector3 SimPosition;
|
|
public Vector3 LookAt;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (ObjectName != null) { length += 1 + ObjectName.Length; }
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_objectname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
SimPosition.FromBytes(bytes, i); i += 12;
|
|
LookAt.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(ObjectName == null) { Console.WriteLine("Warning: ObjectName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectName.Length;
|
|
Buffer.BlockCopy(ObjectName, 0, bytes, i, ObjectName.Length); i += ObjectName.Length;
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Buffer.BlockCopy(SimPosition.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
Helpers.FieldToString(output, ObjectName, "ObjectName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("SimPosition: {0}", SimPosition));
|
|
output.Append(String.Format("LookAt: {0}", LookAt));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptTeleportRequest; } }
|
|
public DataBlock Data;
|
|
|
|
public ScriptTeleportRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 195;
|
|
Header.Reliable = true;
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ScriptTeleportRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptTeleportRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptTeleportRequest ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelOverlayPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int SequenceID;
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelOverlay; } }
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelOverlayPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 196;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelOverlayPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelOverlayPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelOverlay ---" + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelPropertiesRequestByIDPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int SequenceID;
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelPropertiesRequestByID; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelPropertiesRequestByIDPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 197;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelPropertiesRequestByIDPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelPropertiesRequestByIDPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelPropertiesRequestByID ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelPropertiesUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public uint Flags;
|
|
public uint ParcelFlags;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _musicurl;
|
|
public byte[] MusicURL
|
|
{
|
|
get { return _musicurl; }
|
|
set
|
|
{
|
|
if (value == null) { _musicurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _musicurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _musicurl, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _mediaurl;
|
|
public byte[] MediaURL
|
|
{
|
|
get { return _mediaurl; }
|
|
set
|
|
{
|
|
if (value == null) { _mediaurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID MediaID;
|
|
public byte MediaAutoScale;
|
|
public UUID GroupID;
|
|
public int PassPrice;
|
|
public float PassHours;
|
|
public byte Category;
|
|
public UUID AuthBuyerID;
|
|
public UUID SnapshotID;
|
|
public Vector3 UserLocation;
|
|
public Vector3 UserLookAt;
|
|
public byte LandingType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 115;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 1 + Desc.Length; }
|
|
if (MusicURL != null) { length += 1 + MusicURL.Length; }
|
|
if (MediaURL != null) { length += 1 + MediaURL.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_musicurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _musicurl, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_mediaurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
|
|
MediaID.FromBytes(bytes, i); i += 16;
|
|
MediaAutoScale = (byte)bytes[i++];
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
PassPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PassHours = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Category = (byte)bytes[i++];
|
|
AuthBuyerID.FromBytes(bytes, i); i += 16;
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
UserLocation.FromBytes(bytes, i); i += 12;
|
|
UserLookAt.FromBytes(bytes, i); i += 12;
|
|
LandingType = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ParcelFlags, bytes, i); i += 4;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Desc.Length;
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
if(MusicURL == null) { Console.WriteLine("Warning: MusicURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MusicURL.Length;
|
|
Buffer.BlockCopy(MusicURL, 0, bytes, i, MusicURL.Length); i += MusicURL.Length;
|
|
if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaURL.Length;
|
|
Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
|
|
Buffer.BlockCopy(MediaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = MediaAutoScale;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(PassPrice, bytes, i); i += 4;
|
|
Utils.FloatToBytes(PassHours, bytes, i); i += 4;
|
|
bytes[i++] = Category;
|
|
Buffer.BlockCopy(AuthBuyerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(UserLocation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(UserLookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = LandingType;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("ParcelFlags: {0}", ParcelFlags));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, MusicURL, "MusicURL");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, MediaURL, "MediaURL");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("MediaID: {0}", MediaID));
|
|
output.AppendLine(String.Format("MediaAutoScale: {0}", MediaAutoScale));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("PassPrice: {0}", PassPrice));
|
|
output.AppendLine(String.Format("PassHours: {0}", PassHours));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
output.AppendLine(String.Format("AuthBuyerID: {0}", AuthBuyerID));
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
output.AppendLine(String.Format("UserLocation: {0}", UserLocation));
|
|
output.AppendLine(String.Format("UserLookAt: {0}", UserLookAt));
|
|
output.Append(String.Format("LandingType: {0}", LandingType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelPropertiesUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelPropertiesUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 198;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelPropertiesUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelPropertiesUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelPropertiesUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelReturnObjectsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public uint ReturnType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ReturnType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ReturnType, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("ReturnType: {0}", ReturnType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TaskIDsBlock : PacketBlock
|
|
{
|
|
public UUID TaskID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TaskIDsBlock() { }
|
|
public TaskIDsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TaskID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TaskIDs --");
|
|
output.Append(String.Format("TaskID: {0}", TaskID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class OwnerIDsBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public OwnerIDsBlock() { }
|
|
public OwnerIDsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- OwnerIDs --");
|
|
output.Append(String.Format("OwnerID: {0}", OwnerID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelReturnObjects; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
public TaskIDsBlock[] TaskIDs;
|
|
public OwnerIDsBlock[] OwnerIDs;
|
|
|
|
public ParcelReturnObjectsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 199;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
TaskIDs = new TaskIDsBlock[0];
|
|
OwnerIDs = new OwnerIDsBlock[0];
|
|
}
|
|
|
|
public ParcelReturnObjectsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(TaskIDs.Length < count) {
|
|
TaskIDs = new TaskIDsBlock[count];
|
|
for(int j = 0; j < count; j++) TaskIDs[j] = new TaskIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ TaskIDs[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(OwnerIDs.Length < count) {
|
|
OwnerIDs = new OwnerIDsBlock[count];
|
|
for(int j = 0; j < count; j++) OwnerIDs[j] = new OwnerIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ OwnerIDs[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelReturnObjectsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(TaskIDs.Length < count) {
|
|
TaskIDs = new TaskIDsBlock[count];
|
|
for(int j = 0; j < count; j++) TaskIDs[j] = new TaskIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ TaskIDs[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(OwnerIDs.Length < count) {
|
|
OwnerIDs = new OwnerIDsBlock[count];
|
|
for(int j = 0; j < count; j++) OwnerIDs[j] = new OwnerIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ OwnerIDs[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
length++;
|
|
for (int j = 0; j < TaskIDs.Length; j++) { length += TaskIDs[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < OwnerIDs.Length; j++) { length += OwnerIDs[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)TaskIDs.Length;
|
|
for (int j = 0; j < TaskIDs.Length; j++) { TaskIDs[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)OwnerIDs.Length;
|
|
for (int j = 0; j < OwnerIDs.Length; j++) { OwnerIDs[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelReturnObjects ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < TaskIDs.Length; j++)
|
|
{
|
|
output += TaskIDs[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < OwnerIDs.Length; j++)
|
|
{
|
|
output += OwnerIDs[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelSetOtherCleanTimePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public int OtherCleanTime;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OtherCleanTime = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.IntToBytes(OtherCleanTime, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("OtherCleanTime: {0}", OtherCleanTime));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelSetOtherCleanTime; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelSetOtherCleanTimePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 200;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelSetOtherCleanTimePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelSetOtherCleanTimePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelSetOtherCleanTime ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDisableObjectsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public uint ReturnType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ReturnType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ReturnType, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("ReturnType: {0}", ReturnType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TaskIDsBlock : PacketBlock
|
|
{
|
|
public UUID TaskID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TaskIDsBlock() { }
|
|
public TaskIDsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TaskID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TaskIDs --");
|
|
output.Append(String.Format("TaskID: {0}", TaskID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class OwnerIDsBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public OwnerIDsBlock() { }
|
|
public OwnerIDsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- OwnerIDs --");
|
|
output.Append(String.Format("OwnerID: {0}", OwnerID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelDisableObjects; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
public TaskIDsBlock[] TaskIDs;
|
|
public OwnerIDsBlock[] OwnerIDs;
|
|
|
|
public ParcelDisableObjectsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 201;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
TaskIDs = new TaskIDsBlock[0];
|
|
OwnerIDs = new OwnerIDsBlock[0];
|
|
}
|
|
|
|
public ParcelDisableObjectsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(TaskIDs.Length < count) {
|
|
TaskIDs = new TaskIDsBlock[count];
|
|
for(int j = 0; j < count; j++) TaskIDs[j] = new TaskIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ TaskIDs[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(OwnerIDs.Length < count) {
|
|
OwnerIDs = new OwnerIDsBlock[count];
|
|
for(int j = 0; j < count; j++) OwnerIDs[j] = new OwnerIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ OwnerIDs[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelDisableObjectsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(TaskIDs.Length < count) {
|
|
TaskIDs = new TaskIDsBlock[count];
|
|
for(int j = 0; j < count; j++) TaskIDs[j] = new TaskIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ TaskIDs[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(OwnerIDs.Length < count) {
|
|
OwnerIDs = new OwnerIDsBlock[count];
|
|
for(int j = 0; j < count; j++) OwnerIDs[j] = new OwnerIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ OwnerIDs[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
length++;
|
|
for (int j = 0; j < TaskIDs.Length; j++) { length += TaskIDs[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < OwnerIDs.Length; j++) { length += OwnerIDs[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)TaskIDs.Length;
|
|
for (int j = 0; j < TaskIDs.Length; j++) { TaskIDs[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)OwnerIDs.Length;
|
|
for (int j = 0; j < OwnerIDs.Length; j++) { OwnerIDs[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelDisableObjects ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < TaskIDs.Length; j++)
|
|
{
|
|
output += TaskIDs[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < OwnerIDs.Length; j++)
|
|
{
|
|
output += OwnerIDs[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelSelectObjectsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public uint ReturnType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ReturnType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ReturnType, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("ReturnType: {0}", ReturnType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ReturnIDsBlock : PacketBlock
|
|
{
|
|
public UUID ReturnID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ReturnIDsBlock() { }
|
|
public ReturnIDsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ReturnID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ReturnID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ReturnIDs --");
|
|
output.Append(String.Format("ReturnID: {0}", ReturnID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelSelectObjects; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
public ReturnIDsBlock[] ReturnIDs;
|
|
|
|
public ParcelSelectObjectsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 202;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
ReturnIDs = new ReturnIDsBlock[0];
|
|
}
|
|
|
|
public ParcelSelectObjectsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ReturnIDs.Length < count) {
|
|
ReturnIDs = new ReturnIDsBlock[count];
|
|
for(int j = 0; j < count; j++) ReturnIDs[j] = new ReturnIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ReturnIDs[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelSelectObjectsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ReturnIDs.Length < count) {
|
|
ReturnIDs = new ReturnIDsBlock[count];
|
|
for(int j = 0; j < count; j++) ReturnIDs[j] = new ReturnIDsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ReturnIDs[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ReturnIDs.Length; j++) { length += ReturnIDs[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ReturnIDs.Length;
|
|
for (int j = 0; j < ReturnIDs.Length; j++) { ReturnIDs[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelSelectObjects ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ReturnIDs.Length; j++)
|
|
{
|
|
output += ReturnIDs[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EstateCovenantRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EstateCovenantRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public EstateCovenantRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 203;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public EstateCovenantRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EstateCovenantRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EstateCovenantRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EstateCovenantReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID CovenantID;
|
|
public uint CovenantTimestamp;
|
|
private byte[] _estatename;
|
|
public byte[] EstateName
|
|
{
|
|
get { return _estatename; }
|
|
set
|
|
{
|
|
if (value == null) { _estatename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _estatename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _estatename, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID EstateOwnerID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 36;
|
|
if (EstateName != null) { length += 1 + EstateName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
CovenantID.FromBytes(bytes, i); i += 16;
|
|
CovenantTimestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_estatename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _estatename, 0, length); i += length;
|
|
EstateOwnerID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(CovenantID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CovenantTimestamp, bytes, i); i += 4;
|
|
if(EstateName == null) { Console.WriteLine("Warning: EstateName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)EstateName.Length;
|
|
Buffer.BlockCopy(EstateName, 0, bytes, i, EstateName.Length); i += EstateName.Length;
|
|
Buffer.BlockCopy(EstateOwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("CovenantID: {0}", CovenantID));
|
|
output.AppendLine(String.Format("CovenantTimestamp: {0}", CovenantTimestamp));
|
|
Helpers.FieldToString(output, EstateName, "EstateName");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("EstateOwnerID: {0}", EstateOwnerID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EstateCovenantReply; } }
|
|
public DataBlock Data;
|
|
|
|
public EstateCovenantReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 204;
|
|
Header.Reliable = true;
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public EstateCovenantReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EstateCovenantReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EstateCovenantReply ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ForceObjectSelectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class HeaderBlock : PacketBlock
|
|
{
|
|
public bool ResetList;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public HeaderBlock() { }
|
|
public HeaderBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ResetList = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((ResetList) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Header --");
|
|
output.Append(String.Format("ResetList: {0}", ResetList));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ForceObjectSelect; } }
|
|
public HeaderBlock _Header;
|
|
public DataBlock[] Data;
|
|
|
|
public ForceObjectSelectPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 205;
|
|
Header.Reliable = true;
|
|
_Header = new HeaderBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public ForceObjectSelectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
_Header.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ForceObjectSelectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
_Header.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += _Header.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
_Header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ForceObjectSelect ---" + Environment.NewLine;
|
|
output += _Header.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelBuyPassPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelBuyPass; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelBuyPassPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 206;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelBuyPassPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelBuyPassPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelBuyPass ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDeedToGroupPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelDeedToGroup; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelDeedToGroupPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 207;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelDeedToGroupPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelDeedToGroupPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelDeedToGroup ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelReclaimPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelReclaim; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelReclaimPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 208;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelReclaimPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelReclaimPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelReclaim ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelClaimPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public bool IsGroupOwned;
|
|
public bool Final;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 18;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Final = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
|
|
bytes[i++] = (byte)((Final) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
|
|
output.Append(String.Format("Final: {0}", Final));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public float West;
|
|
public float South;
|
|
public float East;
|
|
public float North;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
West = Utils.BytesToFloat(bytes, i); i += 4;
|
|
South = Utils.BytesToFloat(bytes, i); i += 4;
|
|
East = Utils.BytesToFloat(bytes, i); i += 4;
|
|
North = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.FloatToBytes(West, bytes, i); i += 4;
|
|
Utils.FloatToBytes(South, bytes, i); i += 4;
|
|
Utils.FloatToBytes(East, bytes, i); i += 4;
|
|
Utils.FloatToBytes(North, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("West: {0}", West));
|
|
output.AppendLine(String.Format("South: {0}", South));
|
|
output.AppendLine(String.Format("East: {0}", East));
|
|
output.Append(String.Format("North: {0}", North));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelClaim; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
public ParcelDataBlock[] ParcelData;
|
|
|
|
public ParcelClaimPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 209;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
ParcelData = new ParcelDataBlock[0];
|
|
}
|
|
|
|
public ParcelClaimPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParcelData.Length < count) {
|
|
ParcelData = new ParcelDataBlock[count];
|
|
for(int j = 0; j < count; j++) ParcelData[j] = new ParcelDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParcelData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelClaimPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParcelData.Length < count) {
|
|
ParcelData = new ParcelDataBlock[count];
|
|
for(int j = 0; j < count; j++) ParcelData[j] = new ParcelDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParcelData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
length++;
|
|
for (int j = 0; j < ParcelData.Length; j++) { length += ParcelData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ParcelData.Length;
|
|
for (int j = 0; j < ParcelData.Length; j++) { ParcelData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelClaim ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ParcelData.Length; j++)
|
|
{
|
|
output += ParcelData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelJoinPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public float West;
|
|
public float South;
|
|
public float East;
|
|
public float North;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
West = Utils.BytesToFloat(bytes, i); i += 4;
|
|
South = Utils.BytesToFloat(bytes, i); i += 4;
|
|
East = Utils.BytesToFloat(bytes, i); i += 4;
|
|
North = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.FloatToBytes(West, bytes, i); i += 4;
|
|
Utils.FloatToBytes(South, bytes, i); i += 4;
|
|
Utils.FloatToBytes(East, bytes, i); i += 4;
|
|
Utils.FloatToBytes(North, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("West: {0}", West));
|
|
output.AppendLine(String.Format("South: {0}", South));
|
|
output.AppendLine(String.Format("East: {0}", East));
|
|
output.Append(String.Format("North: {0}", North));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelJoin; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelJoinPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 210;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelJoinPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelJoinPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelJoin ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDividePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public float West;
|
|
public float South;
|
|
public float East;
|
|
public float North;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
West = Utils.BytesToFloat(bytes, i); i += 4;
|
|
South = Utils.BytesToFloat(bytes, i); i += 4;
|
|
East = Utils.BytesToFloat(bytes, i); i += 4;
|
|
North = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.FloatToBytes(West, bytes, i); i += 4;
|
|
Utils.FloatToBytes(South, bytes, i); i += 4;
|
|
Utils.FloatToBytes(East, bytes, i); i += 4;
|
|
Utils.FloatToBytes(North, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("West: {0}", West));
|
|
output.AppendLine(String.Format("South: {0}", South));
|
|
output.AppendLine(String.Format("East: {0}", East));
|
|
output.Append(String.Format("North: {0}", North));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelDivide; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelDividePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 211;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelDividePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelDividePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelDivide ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelReleasePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelRelease; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelReleasePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 212;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelReleasePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelReleasePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelRelease ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelBuyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public bool IsGroupOwned;
|
|
public bool RemoveContribution;
|
|
public int LocalID;
|
|
public bool Final;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 23;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RemoveContribution = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Final = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
|
|
bytes[i++] = (byte)((RemoveContribution) ? 1 : 0);
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Final) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
|
|
output.AppendLine(String.Format("RemoveContribution: {0}", RemoveContribution));
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("Final: {0}", Final));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int Price;
|
|
public int Area;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Price = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Area = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(Price, bytes, i); i += 4;
|
|
Utils.IntToBytes(Area, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("Price: {0}", Price));
|
|
output.Append(String.Format("Area: {0}", Area));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelBuy; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelBuyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 213;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelBuyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelBuyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelBuy ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelGodForceOwnerPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelGodForceOwner; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelGodForceOwnerPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 214;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelGodForceOwnerPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelGodForceOwnerPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelGodForceOwner ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelAccessListRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public int SequenceID;
|
|
public uint Flags;
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelAccessListRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelAccessListRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 215;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelAccessListRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelAccessListRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelAccessListRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelAccessListReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public int SequenceID;
|
|
public uint Flags;
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 28;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ListBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public int Time;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public ListBlock() { }
|
|
public ListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
Time = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Time, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- List --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("Time: {0}", Time));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelAccessListReply; } }
|
|
public DataBlock Data;
|
|
public ListBlock[] List;
|
|
|
|
public ParcelAccessListReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 216;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Data = new DataBlock();
|
|
List = new ListBlock[0];
|
|
}
|
|
|
|
public ParcelAccessListReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(List.Length < count) {
|
|
List = new ListBlock[count];
|
|
for(int j = 0; j < count; j++) List[j] = new ListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ List[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelAccessListReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(List.Length < count) {
|
|
List = new ListBlock[count];
|
|
for(int j = 0; j < count; j++) List[j] = new ListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ List[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Data.Length;;
|
|
length++;
|
|
for (int j = 0; j < List.Length; j++) { length += List[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)List.Length;
|
|
for (int j = 0; j < List.Length; j++) { List[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelAccessListReply ---" + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < List.Length; j++)
|
|
{
|
|
output += List[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelAccessListUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public uint Flags;
|
|
public int LocalID;
|
|
public UUID TransactionID;
|
|
public int SequenceID;
|
|
public int Sections;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Sections = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
Utils.IntToBytes(Sections, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
output.Append(String.Format("Sections: {0}", Sections));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ListBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public int Time;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public ListBlock() { }
|
|
public ListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
Time = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Time, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- List --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("Time: {0}", Time));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelAccessListUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
public ListBlock[] List;
|
|
|
|
public ParcelAccessListUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 217;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
List = new ListBlock[0];
|
|
}
|
|
|
|
public ParcelAccessListUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(List.Length < count) {
|
|
List = new ListBlock[count];
|
|
for(int j = 0; j < count; j++) List[j] = new ListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ List[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ParcelAccessListUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(List.Length < count) {
|
|
List = new ListBlock[count];
|
|
for(int j = 0; j < count; j++) List[j] = new ListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ List[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
length++;
|
|
for (int j = 0; j < List.Length; j++) { length += List[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)List.Length;
|
|
for (int j = 0; j < List.Length; j++) { List[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelAccessListUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < List.Length; j++)
|
|
{
|
|
output += List[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDwellRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public UUID ParcelID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("ParcelID: {0}", ParcelID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelDwellRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelDwellRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 218;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelDwellRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelDwellRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelDwellRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDwellReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public UUID ParcelID;
|
|
public float Dwell;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelID.FromBytes(bytes, i); i += 16;
|
|
Dwell = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ParcelID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(Dwell, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.AppendLine(String.Format("ParcelID: {0}", ParcelID));
|
|
output.Append(String.Format("Dwell: {0}", Dwell));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelDwellReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ParcelDwellReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 219;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ParcelDwellReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelDwellReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelDwellReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelGodMarkAsContentPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelGodMarkAsContent; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelGodMarkAsContentPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 227;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelGodMarkAsContentPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelGodMarkAsContentPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelGodMarkAsContent ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ViewerStartAuctionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int LocalID;
|
|
public UUID SnapshotID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("SnapshotID: {0}", SnapshotID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ViewerStartAuction; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ViewerStartAuctionPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 228;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ViewerStartAuctionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ViewerStartAuctionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ViewerStartAuction ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UUIDNameRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class UUIDNameBlockBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public UUIDNameBlockBlock() { }
|
|
public UUIDNameBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UUIDNameBlock --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UUIDNameRequest; } }
|
|
public UUIDNameBlockBlock[] UUIDNameBlock;
|
|
|
|
public UUIDNameRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 235;
|
|
Header.Reliable = true;
|
|
UUIDNameBlock = new UUIDNameBlockBlock[0];
|
|
}
|
|
|
|
public UUIDNameRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UUIDNameRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)UUIDNameBlock.Length;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UUIDNameRequest ---" + Environment.NewLine;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++)
|
|
{
|
|
output += UUIDNameBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UUIDNameReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class UUIDNameBlockBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
private byte[] _firstname;
|
|
public byte[] FirstName
|
|
{
|
|
get { return _firstname; }
|
|
set
|
|
{
|
|
if (value == null) { _firstname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _lastname;
|
|
public byte[] LastName
|
|
{
|
|
get { return _lastname; }
|
|
set
|
|
{
|
|
if (value == null) { _lastname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (FirstName != null) { length += 1 + FirstName.Length; }
|
|
if (LastName != null) { length += 1 + LastName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public UUIDNameBlockBlock() { }
|
|
public UUIDNameBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_firstname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_lastname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FirstName.Length;
|
|
Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
|
|
if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LastName.Length;
|
|
Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UUIDNameBlock --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
Helpers.FieldToString(output, FirstName, "FirstName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LastName, "LastName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UUIDNameReply; } }
|
|
public UUIDNameBlockBlock[] UUIDNameBlock;
|
|
|
|
public UUIDNameReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 236;
|
|
Header.Reliable = true;
|
|
UUIDNameBlock = new UUIDNameBlockBlock[0];
|
|
}
|
|
|
|
public UUIDNameReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UUIDNameReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)UUIDNameBlock.Length;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UUIDNameReply ---" + Environment.NewLine;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++)
|
|
{
|
|
output += UUIDNameBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UUIDGroupNameRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class UUIDNameBlockBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public UUIDNameBlockBlock() { }
|
|
public UUIDNameBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UUIDNameBlock --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UUIDGroupNameRequest; } }
|
|
public UUIDNameBlockBlock[] UUIDNameBlock;
|
|
|
|
public UUIDGroupNameRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 237;
|
|
Header.Reliable = true;
|
|
UUIDNameBlock = new UUIDNameBlockBlock[0];
|
|
}
|
|
|
|
public UUIDGroupNameRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UUIDGroupNameRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)UUIDNameBlock.Length;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UUIDGroupNameRequest ---" + Environment.NewLine;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++)
|
|
{
|
|
output += UUIDNameBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UUIDGroupNameReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class UUIDNameBlockBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
private byte[] _groupname;
|
|
public byte[] GroupName
|
|
{
|
|
get { return _groupname; }
|
|
set
|
|
{
|
|
if (value == null) { _groupname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (GroupName != null) { length += 1 + GroupName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public UUIDNameBlockBlock() { }
|
|
public UUIDNameBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_groupname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupName.Length;
|
|
Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UUIDNameBlock --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
Helpers.FieldToString(output, GroupName, "GroupName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UUIDGroupNameReply; } }
|
|
public UUIDNameBlockBlock[] UUIDNameBlock;
|
|
|
|
public UUIDGroupNameReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 238;
|
|
Header.Reliable = true;
|
|
UUIDNameBlock = new UUIDNameBlockBlock[0];
|
|
}
|
|
|
|
public UUIDGroupNameReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UUIDGroupNameReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(UUIDNameBlock.Length < count) {
|
|
UUIDNameBlock = new UUIDNameBlockBlock[count];
|
|
for(int j = 0; j < count; j++) UUIDNameBlock[j] = new UUIDNameBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ UUIDNameBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)UUIDNameBlock.Length;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++) { UUIDNameBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UUIDGroupNameReply ---" + Environment.NewLine;
|
|
for (int j = 0; j < UUIDNameBlock.Length; j++)
|
|
{
|
|
output += UUIDNameBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChildAgentDyingPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChildAgentDying; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ChildAgentDyingPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 240;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ChildAgentDyingPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ChildAgentDyingPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChildAgentDying ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChildAgentUnknownPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChildAgentUnknown; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ChildAgentUnknownPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 241;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ChildAgentUnknownPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ChildAgentUnknownPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChildAgentUnknown ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GetScriptRunningPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ScriptBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public ScriptBlock() { }
|
|
public ScriptBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Script --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GetScriptRunning; } }
|
|
public ScriptBlock Script;
|
|
|
|
public GetScriptRunningPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 243;
|
|
Header.Reliable = true;
|
|
Script = new ScriptBlock();
|
|
}
|
|
|
|
public GetScriptRunningPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GetScriptRunningPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Script.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Script.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GetScriptRunning ---" + Environment.NewLine;
|
|
output += Script.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptRunningReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ScriptBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID ItemID;
|
|
public bool Running;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public ScriptBlock() { }
|
|
public ScriptBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
Running = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Running) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Script --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("Running: {0}", Running));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptRunningReply; } }
|
|
public ScriptBlock Script;
|
|
|
|
public ScriptRunningReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 244;
|
|
Header.Reliable = true;
|
|
Script = new ScriptBlock();
|
|
}
|
|
|
|
public ScriptRunningReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptRunningReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Script.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Script.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptRunningReply ---" + Environment.NewLine;
|
|
output += Script.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SetScriptRunningPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID ItemID;
|
|
public bool Running;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public ScriptBlock() { }
|
|
public ScriptBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
Running = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Running) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Script --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("Running: {0}", Running));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SetScriptRunning; } }
|
|
public AgentDataBlock AgentData;
|
|
public ScriptBlock Script;
|
|
|
|
public SetScriptRunningPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 245;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Script = new ScriptBlock();
|
|
}
|
|
|
|
public SetScriptRunningPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SetScriptRunningPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Script.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Script.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SetScriptRunning ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Script.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptResetPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public ScriptBlock() { }
|
|
public ScriptBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Script --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptReset; } }
|
|
public AgentDataBlock AgentData;
|
|
public ScriptBlock Script;
|
|
|
|
public ScriptResetPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 246;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Script = new ScriptBlock();
|
|
}
|
|
|
|
public ScriptResetPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptResetPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Script.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Script.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Script.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptReset ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Script.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptSensorRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RequesterBlock : PacketBlock
|
|
{
|
|
public UUID SourceID;
|
|
public UUID RequestID;
|
|
public UUID SearchID;
|
|
public Vector3 SearchPos;
|
|
public Quaternion SearchDir;
|
|
private byte[] _searchname;
|
|
public byte[] SearchName
|
|
{
|
|
get { return _searchname; }
|
|
set
|
|
{
|
|
if (value == null) { _searchname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _searchname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _searchname, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Type;
|
|
public float Range;
|
|
public float Arc;
|
|
public ulong RegionHandle;
|
|
public byte SearchRegions;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 93;
|
|
if (SearchName != null) { length += 1 + SearchName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RequesterBlock() { }
|
|
public RequesterBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
SourceID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
SearchID.FromBytes(bytes, i); i += 16;
|
|
SearchPos.FromBytes(bytes, i); i += 12;
|
|
SearchDir.FromBytes(bytes, i, true); i += 12;
|
|
length = (ushort)bytes[i++];
|
|
_searchname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _searchname, 0, length); i += length;
|
|
Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Range = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Arc = Utils.BytesToFloat(bytes, i); i += 4;
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
SearchRegions = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SearchID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SearchPos.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(SearchDir.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
if(SearchName == null) { Console.WriteLine("Warning: SearchName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SearchName.Length;
|
|
Buffer.BlockCopy(SearchName, 0, bytes, i, SearchName.Length); i += SearchName.Length;
|
|
Utils.IntToBytes(Type, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Range, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Arc, bytes, i); i += 4;
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
bytes[i++] = SearchRegions;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Requester --");
|
|
output.AppendLine(String.Format("SourceID: {0}", SourceID));
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("SearchID: {0}", SearchID));
|
|
output.AppendLine(String.Format("SearchPos: {0}", SearchPos));
|
|
output.AppendLine(String.Format("SearchDir: {0}", SearchDir));
|
|
Helpers.FieldToString(output, SearchName, "SearchName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("Range: {0}", Range));
|
|
output.AppendLine(String.Format("Arc: {0}", Arc));
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.Append(String.Format("SearchRegions: {0}", SearchRegions));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptSensorRequest; } }
|
|
public RequesterBlock Requester;
|
|
|
|
public ScriptSensorRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 247;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Requester = new RequesterBlock();
|
|
}
|
|
|
|
public ScriptSensorRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Requester.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ScriptSensorRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Requester.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Requester.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Requester.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptSensorRequest ---" + Environment.NewLine;
|
|
output += Requester.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ScriptSensorReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RequesterBlock : PacketBlock
|
|
{
|
|
public UUID SourceID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public RequesterBlock() { }
|
|
public RequesterBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SourceID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Requester --");
|
|
output.Append(String.Format("SourceID: {0}", SourceID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SensedDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public Vector3 Position;
|
|
public Vector3 Velocity;
|
|
public Quaternion Rotation;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Type;
|
|
public float Range;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 92;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public SensedDataBlock() { }
|
|
public SensedDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
Velocity.FromBytes(bytes, i); i += 12;
|
|
Rotation.FromBytes(bytes, i, true); i += 12;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Range = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Velocity.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
Utils.IntToBytes(Type, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Range, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SensedData --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("Velocity: {0}", Velocity));
|
|
output.AppendLine(String.Format("Rotation: {0}", Rotation));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.Append(String.Format("Range: {0}", Range));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ScriptSensorReply; } }
|
|
public RequesterBlock Requester;
|
|
public SensedDataBlock[] SensedData;
|
|
|
|
public ScriptSensorReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 248;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
Requester = new RequesterBlock();
|
|
SensedData = new SensedDataBlock[0];
|
|
}
|
|
|
|
public ScriptSensorReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Requester.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SensedData.Length < count) {
|
|
SensedData = new SensedDataBlock[count];
|
|
for(int j = 0; j < count; j++) SensedData[j] = new SensedDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SensedData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ScriptSensorReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Requester.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(SensedData.Length < count) {
|
|
SensedData = new SensedDataBlock[count];
|
|
for(int j = 0; j < count; j++) SensedData[j] = new SensedDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ SensedData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += Requester.Length;;
|
|
length++;
|
|
for (int j = 0; j < SensedData.Length; j++) { length += SensedData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Requester.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)SensedData.Length;
|
|
for (int j = 0; j < SensedData.Length; j++) { SensedData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ScriptSensorReply ---" + Environment.NewLine;
|
|
output += Requester.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < SensedData.Length; j++)
|
|
{
|
|
output += SensedData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CompleteAgentMovementPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint CircuitCode;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
CircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CircuitCode, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("CircuitCode: {0}", CircuitCode));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CompleteAgentMovement; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public CompleteAgentMovementPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 249;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public CompleteAgentMovementPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CompleteAgentMovementPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CompleteAgentMovement ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentMovementCompletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public Vector3 Position;
|
|
public Vector3 LookAt;
|
|
public ulong RegionHandle;
|
|
public uint Timestamp;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
LookAt.FromBytes(bytes, i); i += 12;
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Timestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
Utils.UIntToBytes(Timestamp, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("LookAt: {0}", LookAt));
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.Append(String.Format("Timestamp: {0}", Timestamp));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SimDataBlock : PacketBlock
|
|
{
|
|
private byte[] _channelversion;
|
|
public byte[] ChannelVersion
|
|
{
|
|
get { return _channelversion; }
|
|
set
|
|
{
|
|
if (value == null) { _channelversion = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _channelversion = new byte[value.Length]; Buffer.BlockCopy(value, 0, _channelversion, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (ChannelVersion != null) { length += 2 + ChannelVersion.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public SimDataBlock() { }
|
|
public SimDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_channelversion = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _channelversion, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(ChannelVersion == null) { Console.WriteLine("Warning: ChannelVersion is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(ChannelVersion.Length % 256);
|
|
bytes[i++] = (byte)((ChannelVersion.Length >> 8) % 256);
|
|
Buffer.BlockCopy(ChannelVersion, 0, bytes, i, ChannelVersion.Length); i += ChannelVersion.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SimData --");
|
|
Helpers.FieldToString(output, ChannelVersion, "ChannelVersion");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentMovementComplete; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
public SimDataBlock SimData;
|
|
|
|
public AgentMovementCompletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 250;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
SimData = new SimDataBlock();
|
|
}
|
|
|
|
public AgentMovementCompletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
SimData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentMovementCompletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
SimData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length; length += SimData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
SimData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentMovementComplete ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
output += SimData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LogoutRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LogoutRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public LogoutRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 252;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public LogoutRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LogoutRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LogoutRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LogoutReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LogoutReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public LogoutReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 253;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public LogoutReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public LogoutReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LogoutReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImprovedInstantMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MessageBlockBlock : PacketBlock
|
|
{
|
|
public bool FromGroup;
|
|
public UUID ToAgentID;
|
|
public uint ParentEstateID;
|
|
public UUID RegionID;
|
|
public Vector3 Position;
|
|
public byte Offline;
|
|
public byte Dialog;
|
|
public UUID ID;
|
|
public uint Timestamp;
|
|
private byte[] _fromagentname;
|
|
public byte[] FromAgentName
|
|
{
|
|
get { return _fromagentname; }
|
|
set
|
|
{
|
|
if (value == null) { _fromagentname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _fromagentname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _fromagentname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _binarybucket;
|
|
public byte[] BinaryBucket
|
|
{
|
|
get { return _binarybucket; }
|
|
set
|
|
{
|
|
if (value == null) { _binarybucket = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _binarybucket = new byte[value.Length]; Buffer.BlockCopy(value, 0, _binarybucket, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 71;
|
|
if (FromAgentName != null) { length += 1 + FromAgentName.Length; }
|
|
if (Message != null) { length += 2 + Message.Length; }
|
|
if (BinaryBucket != null) { length += 2 + BinaryBucket.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MessageBlockBlock() { }
|
|
public MessageBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
FromGroup = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ToAgentID.FromBytes(bytes, i); i += 16;
|
|
ParentEstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RegionID.FromBytes(bytes, i); i += 16;
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
Offline = (byte)bytes[i++];
|
|
Dialog = (byte)bytes[i++];
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
Timestamp = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_fromagentname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _fromagentname, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_binarybucket = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _binarybucket, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((FromGroup) ? 1 : 0);
|
|
Buffer.BlockCopy(ToAgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(ParentEstateID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = Offline;
|
|
bytes[i++] = Dialog;
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Timestamp, bytes, i); i += 4;
|
|
if(FromAgentName == null) { Console.WriteLine("Warning: FromAgentName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FromAgentName.Length;
|
|
Buffer.BlockCopy(FromAgentName, 0, bytes, i, FromAgentName.Length); i += FromAgentName.Length;
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Message.Length % 256);
|
|
bytes[i++] = (byte)((Message.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
if(BinaryBucket == null) { Console.WriteLine("Warning: BinaryBucket is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(BinaryBucket.Length % 256);
|
|
bytes[i++] = (byte)((BinaryBucket.Length >> 8) % 256);
|
|
Buffer.BlockCopy(BinaryBucket, 0, bytes, i, BinaryBucket.Length); i += BinaryBucket.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MessageBlock --");
|
|
output.AppendLine(String.Format("FromGroup: {0}", FromGroup));
|
|
output.AppendLine(String.Format("ToAgentID: {0}", ToAgentID));
|
|
output.AppendLine(String.Format("ParentEstateID: {0}", ParentEstateID));
|
|
output.AppendLine(String.Format("RegionID: {0}", RegionID));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.AppendLine(String.Format("Offline: {0}", Offline));
|
|
output.AppendLine(String.Format("Dialog: {0}", Dialog));
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("Timestamp: {0}", Timestamp));
|
|
Helpers.FieldToString(output, FromAgentName, "FromAgentName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, BinaryBucket, "BinaryBucket");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ImprovedInstantMessage; } }
|
|
public AgentDataBlock AgentData;
|
|
public MessageBlockBlock MessageBlock;
|
|
|
|
public ImprovedInstantMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 254;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MessageBlock = new MessageBlockBlock();
|
|
}
|
|
|
|
public ImprovedInstantMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MessageBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ImprovedInstantMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MessageBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MessageBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MessageBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ImprovedInstantMessage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MessageBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RetrieveInstantMessagesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RetrieveInstantMessages; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public RetrieveInstantMessagesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 255;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public RetrieveInstantMessagesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RetrieveInstantMessagesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RetrieveInstantMessages ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FindAgentPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentBlockBlock : PacketBlock
|
|
{
|
|
public UUID Hunter;
|
|
public UUID Prey;
|
|
public uint SpaceIP;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentBlockBlock() { }
|
|
public AgentBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Hunter.FromBytes(bytes, i); i += 16;
|
|
Prey.FromBytes(bytes, i); i += 16;
|
|
SpaceIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Hunter.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Prey.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(SpaceIP, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentBlock --");
|
|
output.AppendLine(String.Format("Hunter: {0}", Hunter));
|
|
output.AppendLine(String.Format("Prey: {0}", Prey));
|
|
output.Append(String.Format("SpaceIP: {0}", SpaceIP));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LocationBlockBlock : PacketBlock
|
|
{
|
|
public double GlobalX;
|
|
public double GlobalY;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public LocationBlockBlock() { }
|
|
public LocationBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GlobalX = Utils.BytesToDouble(bytes, i); i += 8;
|
|
GlobalY = Utils.BytesToDouble(bytes, i); i += 8;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.DoubleToBytes(GlobalX, bytes, i); i += 8;
|
|
Utils.DoubleToBytes(GlobalY, bytes, i); i += 8;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- LocationBlock --");
|
|
output.AppendLine(String.Format("GlobalX: {0}", GlobalX));
|
|
output.Append(String.Format("GlobalY: {0}", GlobalY));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.FindAgent; } }
|
|
public AgentBlockBlock AgentBlock;
|
|
public LocationBlockBlock[] LocationBlock;
|
|
|
|
public FindAgentPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 256;
|
|
Header.Reliable = true;
|
|
AgentBlock = new AgentBlockBlock();
|
|
LocationBlock = new LocationBlockBlock[0];
|
|
}
|
|
|
|
public FindAgentPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(LocationBlock.Length < count) {
|
|
LocationBlock = new LocationBlockBlock[count];
|
|
for(int j = 0; j < count; j++) LocationBlock[j] = new LocationBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ LocationBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public FindAgentPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(LocationBlock.Length < count) {
|
|
LocationBlock = new LocationBlockBlock[count];
|
|
for(int j = 0; j < count; j++) LocationBlock[j] = new LocationBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ LocationBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentBlock.Length;;
|
|
length++;
|
|
for (int j = 0; j < LocationBlock.Length; j++) { length += LocationBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentBlock.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)LocationBlock.Length;
|
|
for (int j = 0; j < LocationBlock.Length; j++) { LocationBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- FindAgent ---" + Environment.NewLine;
|
|
output += AgentBlock.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < LocationBlock.Length; j++)
|
|
{
|
|
output += LocationBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestGodlikePowersPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestBlockBlock : PacketBlock
|
|
{
|
|
public bool Godlike;
|
|
public UUID Token;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public RequestBlockBlock() { }
|
|
public RequestBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Token.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((Godlike) ? 1 : 0);
|
|
Buffer.BlockCopy(Token.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestBlock --");
|
|
output.AppendLine(String.Format("Godlike: {0}", Godlike));
|
|
output.Append(String.Format("Token: {0}", Token));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestGodlikePowers; } }
|
|
public AgentDataBlock AgentData;
|
|
public RequestBlockBlock RequestBlock;
|
|
|
|
public RequestGodlikePowersPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 257;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RequestBlock = new RequestBlockBlock();
|
|
}
|
|
|
|
public RequestGodlikePowersPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestGodlikePowersPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RequestBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RequestBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestGodlikePowers ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RequestBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GrantGodlikePowersPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GrantDataBlock : PacketBlock
|
|
{
|
|
public byte GodLevel;
|
|
public UUID Token;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public GrantDataBlock() { }
|
|
public GrantDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GodLevel = (byte)bytes[i++];
|
|
Token.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = GodLevel;
|
|
Buffer.BlockCopy(Token.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GrantData --");
|
|
output.AppendLine(String.Format("GodLevel: {0}", GodLevel));
|
|
output.Append(String.Format("Token: {0}", Token));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GrantGodlikePowers; } }
|
|
public AgentDataBlock AgentData;
|
|
public GrantDataBlock GrantData;
|
|
|
|
public GrantGodlikePowersPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 258;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GrantData = new GrantDataBlock();
|
|
}
|
|
|
|
public GrantGodlikePowersPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GrantData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GrantGodlikePowersPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GrantData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GrantData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GrantData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GrantGodlikePowers ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GrantData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GodlikeMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MethodDataBlock : PacketBlock
|
|
{
|
|
private byte[] _method;
|
|
public byte[] Method
|
|
{
|
|
get { return _method; }
|
|
set
|
|
{
|
|
if (value == null) { _method = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID Invoice;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Method != null) { length += 1 + Method.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MethodDataBlock() { }
|
|
public MethodDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_method = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
|
|
Invoice.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Method.Length;
|
|
Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
|
|
Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MethodData --");
|
|
Helpers.FieldToString(output, Method, "Method");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Invoice: {0}", Invoice));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParamListBlock : PacketBlock
|
|
{
|
|
private byte[] _parameter;
|
|
public byte[] Parameter
|
|
{
|
|
get { return _parameter; }
|
|
set
|
|
{
|
|
if (value == null) { _parameter = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Parameter != null) { length += 1 + Parameter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParamListBlock() { }
|
|
public ParamListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_parameter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Parameter.Length;
|
|
Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParamList --");
|
|
Helpers.FieldToString(output, Parameter, "Parameter");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GodlikeMessage; } }
|
|
public AgentDataBlock AgentData;
|
|
public MethodDataBlock MethodData;
|
|
public ParamListBlock[] ParamList;
|
|
|
|
public GodlikeMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 259;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MethodData = new MethodDataBlock();
|
|
ParamList = new ParamListBlock[0];
|
|
}
|
|
|
|
public GodlikeMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GodlikeMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MethodData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MethodData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ParamList.Length;
|
|
for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GodlikeMessage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MethodData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ParamList.Length; j++)
|
|
{
|
|
output += ParamList[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EstateOwnerMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MethodDataBlock : PacketBlock
|
|
{
|
|
private byte[] _method;
|
|
public byte[] Method
|
|
{
|
|
get { return _method; }
|
|
set
|
|
{
|
|
if (value == null) { _method = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID Invoice;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Method != null) { length += 1 + Method.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MethodDataBlock() { }
|
|
public MethodDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_method = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
|
|
Invoice.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Method.Length;
|
|
Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
|
|
Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MethodData --");
|
|
Helpers.FieldToString(output, Method, "Method");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Invoice: {0}", Invoice));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParamListBlock : PacketBlock
|
|
{
|
|
private byte[] _parameter;
|
|
public byte[] Parameter
|
|
{
|
|
get { return _parameter; }
|
|
set
|
|
{
|
|
if (value == null) { _parameter = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Parameter != null) { length += 1 + Parameter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParamListBlock() { }
|
|
public ParamListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_parameter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Parameter.Length;
|
|
Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParamList --");
|
|
Helpers.FieldToString(output, Parameter, "Parameter");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EstateOwnerMessage; } }
|
|
public AgentDataBlock AgentData;
|
|
public MethodDataBlock MethodData;
|
|
public ParamListBlock[] ParamList;
|
|
|
|
public EstateOwnerMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 260;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MethodData = new MethodDataBlock();
|
|
ParamList = new ParamListBlock[0];
|
|
}
|
|
|
|
public EstateOwnerMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public EstateOwnerMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MethodData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MethodData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ParamList.Length;
|
|
for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EstateOwnerMessage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MethodData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ParamList.Length; j++)
|
|
{
|
|
output += ParamList[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GenericMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MethodDataBlock : PacketBlock
|
|
{
|
|
private byte[] _method;
|
|
public byte[] Method
|
|
{
|
|
get { return _method; }
|
|
set
|
|
{
|
|
if (value == null) { _method = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID Invoice;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Method != null) { length += 1 + Method.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MethodDataBlock() { }
|
|
public MethodDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_method = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
|
|
Invoice.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Method.Length;
|
|
Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
|
|
Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MethodData --");
|
|
Helpers.FieldToString(output, Method, "Method");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Invoice: {0}", Invoice));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParamListBlock : PacketBlock
|
|
{
|
|
private byte[] _parameter;
|
|
public byte[] Parameter
|
|
{
|
|
get { return _parameter; }
|
|
set
|
|
{
|
|
if (value == null) { _parameter = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Parameter != null) { length += 1 + Parameter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParamListBlock() { }
|
|
public ParamListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_parameter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Parameter.Length;
|
|
Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParamList --");
|
|
Helpers.FieldToString(output, Parameter, "Parameter");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GenericMessage; } }
|
|
public AgentDataBlock AgentData;
|
|
public MethodDataBlock MethodData;
|
|
public ParamListBlock[] ParamList;
|
|
|
|
public GenericMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 261;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MethodData = new MethodDataBlock();
|
|
ParamList = new ParamListBlock[0];
|
|
}
|
|
|
|
public GenericMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GenericMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MethodData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MethodData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ParamList.Length;
|
|
for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GenericMessage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MethodData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ParamList.Length; j++)
|
|
{
|
|
output += ParamList[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MuteListRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MuteDataBlock : PacketBlock
|
|
{
|
|
public uint MuteCRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public MuteDataBlock() { }
|
|
public MuteDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
MuteCRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(MuteCRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MuteData --");
|
|
output.Append(String.Format("MuteCRC: {0}", MuteCRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MuteListRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public MuteDataBlock MuteData;
|
|
|
|
public MuteListRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 262;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
MuteData = new MuteDataBlock();
|
|
}
|
|
|
|
public MuteListRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MuteListRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MuteData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MuteData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MuteListRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MuteData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateMuteListEntryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MuteDataBlock : PacketBlock
|
|
{
|
|
public UUID MuteID;
|
|
private byte[] _mutename;
|
|
public byte[] MuteName
|
|
{
|
|
get { return _mutename; }
|
|
set
|
|
{
|
|
if (value == null) { _mutename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mutename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mutename, 0, value.Length); }
|
|
}
|
|
}
|
|
public int MuteType;
|
|
public uint MuteFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (MuteName != null) { length += 1 + MuteName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MuteDataBlock() { }
|
|
public MuteDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
MuteID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_mutename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mutename, 0, length); i += length;
|
|
MuteType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
MuteFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(MuteID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(MuteName == null) { Console.WriteLine("Warning: MuteName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MuteName.Length;
|
|
Buffer.BlockCopy(MuteName, 0, bytes, i, MuteName.Length); i += MuteName.Length;
|
|
Utils.IntToBytes(MuteType, bytes, i); i += 4;
|
|
Utils.UIntToBytes(MuteFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MuteData --");
|
|
output.AppendLine(String.Format("MuteID: {0}", MuteID));
|
|
Helpers.FieldToString(output, MuteName, "MuteName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("MuteType: {0}", MuteType));
|
|
output.Append(String.Format("MuteFlags: {0}", MuteFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateMuteListEntry; } }
|
|
public AgentDataBlock AgentData;
|
|
public MuteDataBlock MuteData;
|
|
|
|
public UpdateMuteListEntryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 263;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
MuteData = new MuteDataBlock();
|
|
}
|
|
|
|
public UpdateMuteListEntryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UpdateMuteListEntryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MuteData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MuteData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateMuteListEntry ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MuteData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RemoveMuteListEntryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MuteDataBlock : PacketBlock
|
|
{
|
|
public UUID MuteID;
|
|
private byte[] _mutename;
|
|
public byte[] MuteName
|
|
{
|
|
get { return _mutename; }
|
|
set
|
|
{
|
|
if (value == null) { _mutename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mutename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mutename, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (MuteName != null) { length += 1 + MuteName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MuteDataBlock() { }
|
|
public MuteDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
MuteID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_mutename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mutename, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(MuteID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(MuteName == null) { Console.WriteLine("Warning: MuteName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MuteName.Length;
|
|
Buffer.BlockCopy(MuteName, 0, bytes, i, MuteName.Length); i += MuteName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MuteData --");
|
|
output.AppendLine(String.Format("MuteID: {0}", MuteID));
|
|
Helpers.FieldToString(output, MuteName, "MuteName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RemoveMuteListEntry; } }
|
|
public AgentDataBlock AgentData;
|
|
public MuteDataBlock MuteData;
|
|
|
|
public RemoveMuteListEntryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 264;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
MuteData = new MuteDataBlock();
|
|
}
|
|
|
|
public RemoveMuteListEntryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RemoveMuteListEntryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MuteData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MuteData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RemoveMuteListEntry ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MuteData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CopyInventoryFromNotecardPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NotecardDataBlock : PacketBlock
|
|
{
|
|
public UUID NotecardItemID;
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public NotecardDataBlock() { }
|
|
public NotecardDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
NotecardItemID.FromBytes(bytes, i); i += 16;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(NotecardItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NotecardData --");
|
|
output.AppendLine(String.Format("NotecardItemID: {0}", NotecardItemID));
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CopyInventoryFromNotecard; } }
|
|
public AgentDataBlock AgentData;
|
|
public NotecardDataBlock NotecardData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public CopyInventoryFromNotecardPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 265;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
NotecardData = new NotecardDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public CopyInventoryFromNotecardPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
NotecardData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public CopyInventoryFromNotecardPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
NotecardData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += NotecardData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
NotecardData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CopyInventoryFromNotecard ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += NotecardData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateInventoryItemPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public uint CallbackID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID TransactionID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 140;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CallbackID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateInventoryItem; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public UpdateInventoryItemPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 266;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public UpdateInventoryItemPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UpdateInventoryItemPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateInventoryItem ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateCreateInventoryItemPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public bool SimApproved;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SimApproved = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((SimApproved) ? 1 : 0);
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SimApproved: {0}", SimApproved));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public uint CallbackID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID AssetID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 140;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CallbackID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateCreateInventoryItem; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public UpdateCreateInventoryItemPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 267;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public UpdateCreateInventoryItemPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UpdateCreateInventoryItemPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateCreateInventoryItem ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoveInventoryItemPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public bool Stamp;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Stamp = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Stamp) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("Stamp: {0}", Stamp));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
private byte[] _newname;
|
|
public byte[] NewName
|
|
{
|
|
get { return _newname; }
|
|
set
|
|
{
|
|
if (value == null) { _newname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _newname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _newname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 32;
|
|
if (NewName != null) { length += 1 + NewName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_newname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _newname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(NewName == null) { Console.WriteLine("Warning: NewName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)NewName.Length;
|
|
Buffer.BlockCopy(NewName, 0, bytes, i, NewName.Length); i += NewName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
Helpers.FieldToString(output, NewName, "NewName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MoveInventoryItem; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public MoveInventoryItemPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 268;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public MoveInventoryItemPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MoveInventoryItemPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MoveInventoryItem ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CopyInventoryItemPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public uint CallbackID;
|
|
public UUID OldAgentID;
|
|
public UUID OldItemID;
|
|
public UUID NewFolderID;
|
|
private byte[] _newname;
|
|
public byte[] NewName
|
|
{
|
|
get { return _newname; }
|
|
set
|
|
{
|
|
if (value == null) { _newname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _newname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _newname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 52;
|
|
if (NewName != null) { length += 1 + NewName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OldAgentID.FromBytes(bytes, i); i += 16;
|
|
OldItemID.FromBytes(bytes, i); i += 16;
|
|
NewFolderID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_newname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _newname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(CallbackID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(OldAgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OldItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(NewFolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(NewName == null) { Console.WriteLine("Warning: NewName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)NewName.Length;
|
|
Buffer.BlockCopy(NewName, 0, bytes, i, NewName.Length); i += NewName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
|
|
output.AppendLine(String.Format("OldAgentID: {0}", OldAgentID));
|
|
output.AppendLine(String.Format("OldItemID: {0}", OldItemID));
|
|
output.AppendLine(String.Format("NewFolderID: {0}", NewFolderID));
|
|
Helpers.FieldToString(output, NewName, "NewName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CopyInventoryItem; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public CopyInventoryItemPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 269;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public CopyInventoryItemPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public CopyInventoryItemPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CopyInventoryItem ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RemoveInventoryItemPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RemoveInventoryItem; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public RemoveInventoryItemPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 270;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public RemoveInventoryItemPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RemoveInventoryItemPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RemoveInventoryItem ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChangeInventoryItemFlagsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChangeInventoryItemFlags; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public ChangeInventoryItemFlagsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 271;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public ChangeInventoryItemFlagsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ChangeInventoryItemFlagsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChangeInventoryItemFlags ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SaveAssetIntoInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID NewAssetID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
NewAssetID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(NewAssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("NewAssetID: {0}", NewAssetID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SaveAssetIntoInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public SaveAssetIntoInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 272;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public SaveAssetIntoInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SaveAssetIntoInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SaveAssetIntoInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateInventoryFolderPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
public UUID ParentID;
|
|
public sbyte Type;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 33;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
ParentID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("ParentID: {0}", ParentID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateInventoryFolder; } }
|
|
public AgentDataBlock AgentData;
|
|
public FolderDataBlock FolderData;
|
|
|
|
public CreateInventoryFolderPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 273;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FolderData = new FolderDataBlock();
|
|
}
|
|
|
|
public CreateInventoryFolderPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FolderData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CreateInventoryFolderPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FolderData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += FolderData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
FolderData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateInventoryFolder ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += FolderData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateInventoryFolderPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
public UUID ParentID;
|
|
public sbyte Type;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 33;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
ParentID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("ParentID: {0}", ParentID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateInventoryFolder; } }
|
|
public AgentDataBlock AgentData;
|
|
public FolderDataBlock[] FolderData;
|
|
|
|
public UpdateInventoryFolderPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 274;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
}
|
|
|
|
public UpdateInventoryFolderPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public UpdateInventoryFolderPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateInventoryFolder ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoveInventoryFolderPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public bool Stamp;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Stamp = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Stamp) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("Stamp: {0}", Stamp));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
public UUID ParentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
ParentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.Append(String.Format("ParentID: {0}", ParentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MoveInventoryFolder; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public MoveInventoryFolderPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 275;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public MoveInventoryFolderPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MoveInventoryFolderPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MoveInventoryFolder ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RemoveInventoryFolderPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RemoveInventoryFolder; } }
|
|
public AgentDataBlock AgentData;
|
|
public FolderDataBlock[] FolderData;
|
|
|
|
public RemoveInventoryFolderPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 276;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
}
|
|
|
|
public RemoveInventoryFolderPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RemoveInventoryFolderPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RemoveInventoryFolder ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FetchInventoryDescendentsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
public UUID OwnerID;
|
|
public int SortOrder;
|
|
public bool FetchFolders;
|
|
public bool FetchItems;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 38;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
SortOrder = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
FetchFolders = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
FetchItems = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(SortOrder, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((FetchFolders) ? 1 : 0);
|
|
bytes[i++] = (byte)((FetchItems) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("SortOrder: {0}", SortOrder));
|
|
output.AppendLine(String.Format("FetchFolders: {0}", FetchFolders));
|
|
output.Append(String.Format("FetchItems: {0}", FetchItems));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.FetchInventoryDescendents; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public FetchInventoryDescendentsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 277;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public FetchInventoryDescendentsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public FetchInventoryDescendentsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- FetchInventoryDescendents ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDescendentsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID FolderID;
|
|
public UUID OwnerID;
|
|
public int Version;
|
|
public int Descendents;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 56;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
Version = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Descendents = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Version, bytes, i); i += 4;
|
|
Utils.IntToBytes(Descendents, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("Version: {0}", Version));
|
|
output.Append(String.Format("Descendents: {0}", Descendents));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
public UUID ParentID;
|
|
public sbyte Type;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 33;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
ParentID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("ParentID: {0}", ParentID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ItemDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID AssetID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 136;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ItemDataBlock() { }
|
|
public ItemDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ItemData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.InventoryDescendents; } }
|
|
public AgentDataBlock AgentData;
|
|
public FolderDataBlock[] FolderData;
|
|
public ItemDataBlock[] ItemData;
|
|
|
|
public InventoryDescendentsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 278;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
ItemData = new ItemDataBlock[0];
|
|
}
|
|
|
|
public InventoryDescendentsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(ItemData.Length < count) {
|
|
ItemData = new ItemDataBlock[count];
|
|
for(int j = 0; j < count; j++) ItemData[j] = new ItemDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ItemData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public InventoryDescendentsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(ItemData.Length < count) {
|
|
ItemData = new ItemDataBlock[count];
|
|
for(int j = 0; j < count; j++) ItemData[j] = new ItemDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ItemData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < ItemData.Length; j++) { length += ItemData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)ItemData.Length;
|
|
for (int j = 0; j < ItemData.Length; j++) { ItemData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- InventoryDescendents ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < ItemData.Length; j++)
|
|
{
|
|
output += ItemData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FetchInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID OwnerID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.FetchInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public FetchInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 279;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public FetchInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public FetchInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- FetchInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FetchInventoryReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID AssetID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 136;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.FetchInventoryReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public FetchInventoryReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 280;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public FetchInventoryReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public FetchInventoryReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- FetchInventoryReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class BulkUpdateInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
public UUID ParentID;
|
|
public sbyte Type;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 33;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
ParentID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("ParentID: {0}", ParentID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ItemDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public uint CallbackID;
|
|
public UUID FolderID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID AssetID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 140;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ItemDataBlock() { }
|
|
public ItemDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CallbackID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ItemData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.BulkUpdateInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public FolderDataBlock[] FolderData;
|
|
public ItemDataBlock[] ItemData;
|
|
|
|
public BulkUpdateInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 281;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
ItemData = new ItemDataBlock[0];
|
|
}
|
|
|
|
public BulkUpdateInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(ItemData.Length < count) {
|
|
ItemData = new ItemDataBlock[count];
|
|
for(int j = 0; j < count; j++) ItemData[j] = new ItemDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ItemData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public BulkUpdateInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(ItemData.Length < count) {
|
|
ItemData = new ItemDataBlock[count];
|
|
for(int j = 0; j < count; j++) ItemData[j] = new ItemDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ItemData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < ItemData.Length; j++) { length += ItemData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)ItemData.Length;
|
|
for (int j = 0; j < ItemData.Length; j++) { ItemData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- BulkUpdateInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < ItemData.Length; j++)
|
|
{
|
|
output += ItemData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestInventoryAssetPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
public UUID AgentID;
|
|
public UUID OwnerID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestInventoryAsset; } }
|
|
public QueryDataBlock QueryData;
|
|
|
|
public RequestInventoryAssetPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 282;
|
|
Header.Reliable = true;
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public RequestInventoryAssetPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestInventoryAssetPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestInventoryAsset ---" + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryAssetResponsePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class QueryDataBlock : PacketBlock
|
|
{
|
|
public UUID QueryID;
|
|
public UUID AssetID;
|
|
public bool IsReadable;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public QueryDataBlock() { }
|
|
public QueryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
QueryID.FromBytes(bytes, i); i += 16;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
IsReadable = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(QueryID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsReadable) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- QueryData --");
|
|
output.AppendLine(String.Format("QueryID: {0}", QueryID));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.Append(String.Format("IsReadable: {0}", IsReadable));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.InventoryAssetResponse; } }
|
|
public QueryDataBlock QueryData;
|
|
|
|
public InventoryAssetResponsePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 283;
|
|
Header.Reliable = true;
|
|
QueryData = new QueryDataBlock();
|
|
}
|
|
|
|
public InventoryAssetResponsePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public InventoryAssetResponsePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
QueryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += QueryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
QueryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- InventoryAssetResponse ---" + Environment.NewLine;
|
|
output += QueryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RemoveInventoryObjectsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ItemDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ItemDataBlock() { }
|
|
public ItemDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ItemData --");
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RemoveInventoryObjects; } }
|
|
public AgentDataBlock AgentData;
|
|
public FolderDataBlock[] FolderData;
|
|
public ItemDataBlock[] ItemData;
|
|
|
|
public RemoveInventoryObjectsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 284;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
ItemData = new ItemDataBlock[0];
|
|
}
|
|
|
|
public RemoveInventoryObjectsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(ItemData.Length < count) {
|
|
ItemData = new ItemDataBlock[count];
|
|
for(int j = 0; j < count; j++) ItemData[j] = new ItemDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ItemData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RemoveInventoryObjectsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(ItemData.Length < count) {
|
|
ItemData = new ItemDataBlock[count];
|
|
for(int j = 0; j < count; j++) ItemData[j] = new ItemDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ItemData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < ItemData.Length; j++) { length += ItemData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)ItemData.Length;
|
|
for (int j = 0; j < ItemData.Length; j++) { ItemData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RemoveInventoryObjects ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < ItemData.Length; j++)
|
|
{
|
|
output += ItemData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PurgeInventoryDescendentsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PurgeInventoryDescendents; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public PurgeInventoryDescendentsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 285;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public PurgeInventoryDescendentsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public PurgeInventoryDescendentsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PurgeInventoryDescendents ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateTaskInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
public byte Key;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public UpdateDataBlock() { }
|
|
public UpdateDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Key = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
bytes[i++] = Key;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UpdateData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("Key: {0}", Key));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID TransactionID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 136;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateTaskInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public UpdateDataBlock UpdateData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public UpdateTaskInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 286;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
UpdateData = new UpdateDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public UpdateTaskInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UpdateData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UpdateTaskInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UpdateData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += UpdateData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
UpdateData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateTaskInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += UpdateData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RemoveTaskInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RemoveTaskInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public RemoveTaskInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 287;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public RemoveTaskInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RemoveTaskInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RemoveTaskInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoveTaskInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MoveTaskInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public MoveTaskInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 288;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public MoveTaskInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MoveTaskInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MoveTaskInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestTaskInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public uint LocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
LocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(LocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.Append(String.Format("LocalID: {0}", LocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestTaskInventory; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public RequestTaskInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 289;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public RequestTaskInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestTaskInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestTaskInventory ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ReplyTaskInventoryPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID TaskID;
|
|
public short Serial;
|
|
private byte[] _filename;
|
|
public byte[] Filename
|
|
{
|
|
get { return _filename; }
|
|
set
|
|
{
|
|
if (value == null) { _filename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 18;
|
|
if (Filename != null) { length += 1 + Filename.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TaskID.FromBytes(bytes, i); i += 16;
|
|
Serial = (short)(bytes[i++] + (bytes[i++] << 8));
|
|
length = (ushort)bytes[i++];
|
|
_filename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)(Serial % 256);
|
|
bytes[i++] = (byte)((Serial >> 8) % 256);
|
|
if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Filename.Length;
|
|
Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("TaskID: {0}", TaskID));
|
|
output.AppendLine(String.Format("Serial: {0}", Serial));
|
|
Helpers.FieldToString(output, Filename, "Filename");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ReplyTaskInventory; } }
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public ReplyTaskInventoryPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 290;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public ReplyTaskInventoryPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ReplyTaskInventoryPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ReplyTaskInventory ---" + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DeRezObjectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentBlockBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public byte Destination;
|
|
public UUID DestinationID;
|
|
public UUID TransactionID;
|
|
public byte PacketCount;
|
|
public byte PacketNumber;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 51;
|
|
}
|
|
}
|
|
|
|
public AgentBlockBlock() { }
|
|
public AgentBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Destination = (byte)bytes[i++];
|
|
DestinationID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
PacketCount = (byte)bytes[i++];
|
|
PacketNumber = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = Destination;
|
|
Buffer.BlockCopy(DestinationID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = PacketCount;
|
|
bytes[i++] = PacketNumber;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentBlock --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("Destination: {0}", Destination));
|
|
output.AppendLine(String.Format("DestinationID: {0}", DestinationID));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("PacketCount: {0}", PacketCount));
|
|
output.Append(String.Format("PacketNumber: {0}", PacketNumber));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DeRezObject; } }
|
|
public AgentDataBlock AgentData;
|
|
public AgentBlockBlock AgentBlock;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public DeRezObjectPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 291;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
AgentBlock = new AgentBlockBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public DeRezObjectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DeRezObjectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += AgentBlock.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
AgentBlock.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DeRezObject ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += AgentBlock.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DeRezAckPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
public bool Success;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Success) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.Append(String.Format("Success: {0}", Success));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DeRezAck; } }
|
|
public TransactionDataBlock TransactionData;
|
|
|
|
public DeRezAckPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 292;
|
|
Header.Reliable = true;
|
|
TransactionData = new TransactionDataBlock();
|
|
}
|
|
|
|
public DeRezAckPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DeRezAckPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TransactionData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DeRezAck ---" + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezObjectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezDataBlock : PacketBlock
|
|
{
|
|
public UUID FromTaskID;
|
|
public byte BypassRaycast;
|
|
public Vector3 RayStart;
|
|
public Vector3 RayEnd;
|
|
public UUID RayTargetID;
|
|
public bool RayEndIsIntersection;
|
|
public bool RezSelected;
|
|
public bool RemoveItem;
|
|
public uint ItemFlags;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 76;
|
|
}
|
|
}
|
|
|
|
public RezDataBlock() { }
|
|
public RezDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FromTaskID.FromBytes(bytes, i); i += 16;
|
|
BypassRaycast = (byte)bytes[i++];
|
|
RayStart.FromBytes(bytes, i); i += 12;
|
|
RayEnd.FromBytes(bytes, i); i += 12;
|
|
RayTargetID.FromBytes(bytes, i); i += 16;
|
|
RayEndIsIntersection = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RezSelected = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RemoveItem = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FromTaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = BypassRaycast;
|
|
Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((RayEndIsIntersection) ? 1 : 0);
|
|
bytes[i++] = (byte)((RezSelected) ? 1 : 0);
|
|
bytes[i++] = (byte)((RemoveItem) ? 1 : 0);
|
|
Utils.UIntToBytes(ItemFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RezData --");
|
|
output.AppendLine(String.Format("FromTaskID: {0}", FromTaskID));
|
|
output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
|
|
output.AppendLine(String.Format("RayStart: {0}", RayStart));
|
|
output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
|
|
output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
|
|
output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
|
|
output.AppendLine(String.Format("RezSelected: {0}", RezSelected));
|
|
output.AppendLine(String.Format("RemoveItem: {0}", RemoveItem));
|
|
output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.Append(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID TransactionID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 136;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RezObject; } }
|
|
public AgentDataBlock AgentData;
|
|
public RezDataBlock RezData;
|
|
public InventoryDataBlock InventoryData;
|
|
|
|
public RezObjectPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 293;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
RezData = new RezDataBlock();
|
|
InventoryData = new InventoryDataBlock();
|
|
}
|
|
|
|
public RezObjectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RezData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RezObjectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RezData.FromBytes(bytes, ref i);
|
|
InventoryData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RezData.Length; length += InventoryData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RezData.ToBytes(bytes, ref i);
|
|
InventoryData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RezObject ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RezData.ToString() + Environment.NewLine;
|
|
output += InventoryData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezObjectFromNotecardPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezDataBlock : PacketBlock
|
|
{
|
|
public UUID FromTaskID;
|
|
public byte BypassRaycast;
|
|
public Vector3 RayStart;
|
|
public Vector3 RayEnd;
|
|
public UUID RayTargetID;
|
|
public bool RayEndIsIntersection;
|
|
public bool RezSelected;
|
|
public bool RemoveItem;
|
|
public uint ItemFlags;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 76;
|
|
}
|
|
}
|
|
|
|
public RezDataBlock() { }
|
|
public RezDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FromTaskID.FromBytes(bytes, i); i += 16;
|
|
BypassRaycast = (byte)bytes[i++];
|
|
RayStart.FromBytes(bytes, i); i += 12;
|
|
RayEnd.FromBytes(bytes, i); i += 12;
|
|
RayTargetID.FromBytes(bytes, i); i += 16;
|
|
RayEndIsIntersection = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RezSelected = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RemoveItem = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FromTaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = BypassRaycast;
|
|
Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((RayEndIsIntersection) ? 1 : 0);
|
|
bytes[i++] = (byte)((RezSelected) ? 1 : 0);
|
|
bytes[i++] = (byte)((RemoveItem) ? 1 : 0);
|
|
Utils.UIntToBytes(ItemFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RezData --");
|
|
output.AppendLine(String.Format("FromTaskID: {0}", FromTaskID));
|
|
output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
|
|
output.AppendLine(String.Format("RayStart: {0}", RayStart));
|
|
output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
|
|
output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
|
|
output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
|
|
output.AppendLine(String.Format("RezSelected: {0}", RezSelected));
|
|
output.AppendLine(String.Format("RemoveItem: {0}", RemoveItem));
|
|
output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.Append(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NotecardDataBlock : PacketBlock
|
|
{
|
|
public UUID NotecardItemID;
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public NotecardDataBlock() { }
|
|
public NotecardDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
NotecardItemID.FromBytes(bytes, i); i += 16;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(NotecardItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NotecardData --");
|
|
output.AppendLine(String.Format("NotecardItemID: {0}", NotecardItemID));
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public InventoryDataBlock() { }
|
|
public InventoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryData --");
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RezObjectFromNotecard; } }
|
|
public AgentDataBlock AgentData;
|
|
public RezDataBlock RezData;
|
|
public NotecardDataBlock NotecardData;
|
|
public InventoryDataBlock[] InventoryData;
|
|
|
|
public RezObjectFromNotecardPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 294;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
RezData = new RezDataBlock();
|
|
NotecardData = new NotecardDataBlock();
|
|
InventoryData = new InventoryDataBlock[0];
|
|
}
|
|
|
|
public RezObjectFromNotecardPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RezData.FromBytes(bytes, ref i);
|
|
NotecardData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RezObjectFromNotecardPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RezData.FromBytes(bytes, ref i);
|
|
NotecardData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InventoryData.Length < count) {
|
|
InventoryData = new InventoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) InventoryData[j] = new InventoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InventoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RezData.Length; length += NotecardData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RezData.ToBytes(bytes, ref i);
|
|
NotecardData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InventoryData.Length;
|
|
for (int j = 0; j < InventoryData.Length; j++) { InventoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RezObjectFromNotecard ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RezData.ToString() + Environment.NewLine;
|
|
output += NotecardData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InventoryData.Length; j++)
|
|
{
|
|
output += InventoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AcceptFriendshipPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionBlockBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionBlockBlock() { }
|
|
public TransactionBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionBlock --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AcceptFriendship; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionBlockBlock TransactionBlock;
|
|
public FolderDataBlock[] FolderData;
|
|
|
|
public AcceptFriendshipPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 297;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionBlock = new TransactionBlockBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
}
|
|
|
|
public AcceptFriendshipPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AcceptFriendshipPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionBlock.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionBlock.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AcceptFriendship ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionBlock.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DeclineFriendshipPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionBlockBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionBlockBlock() { }
|
|
public TransactionBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionBlock --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DeclineFriendship; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionBlockBlock TransactionBlock;
|
|
|
|
public DeclineFriendshipPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 298;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionBlock = new TransactionBlockBlock();
|
|
}
|
|
|
|
public DeclineFriendshipPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DeclineFriendshipPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DeclineFriendship ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FormFriendshipPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentBlockBlock : PacketBlock
|
|
{
|
|
public UUID SourceID;
|
|
public UUID DestID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentBlockBlock() { }
|
|
public AgentBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SourceID.FromBytes(bytes, i); i += 16;
|
|
DestID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(DestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentBlock --");
|
|
output.AppendLine(String.Format("SourceID: {0}", SourceID));
|
|
output.Append(String.Format("DestID: {0}", DestID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.FormFriendship; } }
|
|
public AgentBlockBlock AgentBlock;
|
|
|
|
public FormFriendshipPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 299;
|
|
Header.Reliable = true;
|
|
AgentBlock = new AgentBlockBlock();
|
|
}
|
|
|
|
public FormFriendshipPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public FormFriendshipPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- FormFriendship ---" + Environment.NewLine;
|
|
output += AgentBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TerminateFriendshipPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ExBlockBlock : PacketBlock
|
|
{
|
|
public UUID OtherID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ExBlockBlock() { }
|
|
public ExBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OtherID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OtherID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ExBlock --");
|
|
output.Append(String.Format("OtherID: {0}", OtherID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TerminateFriendship; } }
|
|
public AgentDataBlock AgentData;
|
|
public ExBlockBlock ExBlock;
|
|
|
|
public TerminateFriendshipPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 300;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ExBlock = new ExBlockBlock();
|
|
}
|
|
|
|
public TerminateFriendshipPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ExBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TerminateFriendshipPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ExBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ExBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ExBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TerminateFriendship ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ExBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class OfferCallingCardPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentBlockBlock : PacketBlock
|
|
{
|
|
public UUID DestID;
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentBlockBlock() { }
|
|
public AgentBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
DestID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(DestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentBlock --");
|
|
output.AppendLine(String.Format("DestID: {0}", DestID));
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.OfferCallingCard; } }
|
|
public AgentDataBlock AgentData;
|
|
public AgentBlockBlock AgentBlock;
|
|
|
|
public OfferCallingCardPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 301;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
AgentBlock = new AgentBlockBlock();
|
|
}
|
|
|
|
public OfferCallingCardPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public OfferCallingCardPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
AgentBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += AgentBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
AgentBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- OfferCallingCard ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += AgentBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AcceptCallingCardPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionBlockBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionBlockBlock() { }
|
|
public TransactionBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionBlock --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FolderDataBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public FolderDataBlock() { }
|
|
public FolderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FolderData --");
|
|
output.Append(String.Format("FolderID: {0}", FolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AcceptCallingCard; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionBlockBlock TransactionBlock;
|
|
public FolderDataBlock[] FolderData;
|
|
|
|
public AcceptCallingCardPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 302;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionBlock = new TransactionBlockBlock();
|
|
FolderData = new FolderDataBlock[0];
|
|
}
|
|
|
|
public AcceptCallingCardPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AcceptCallingCardPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(FolderData.Length < count) {
|
|
FolderData = new FolderDataBlock[count];
|
|
for(int j = 0; j < count; j++) FolderData[j] = new FolderDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ FolderData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionBlock.Length;;
|
|
length++;
|
|
for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionBlock.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)FolderData.Length;
|
|
for (int j = 0; j < FolderData.Length; j++) { FolderData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AcceptCallingCard ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionBlock.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < FolderData.Length; j++)
|
|
{
|
|
output += FolderData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DeclineCallingCardPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionBlockBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionBlockBlock() { }
|
|
public TransactionBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionBlock --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DeclineCallingCard; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionBlockBlock TransactionBlock;
|
|
|
|
public DeclineCallingCardPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 303;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionBlock = new TransactionBlockBlock();
|
|
}
|
|
|
|
public DeclineCallingCardPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DeclineCallingCardPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DeclineCallingCard ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezScriptPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateBlockBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public bool Enabled;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public UpdateBlockBlock() { }
|
|
public UpdateBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Enabled = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Enabled) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UpdateBlock --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("Enabled: {0}", Enabled));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryBlockBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public bool GroupOwned;
|
|
public UUID TransactionID;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public uint Flags;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int CreationDate;
|
|
public uint CRC;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 136;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryBlockBlock() { }
|
|
public InventoryBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
CreationDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((GroupOwned) ? 1 : 0);
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(CreationDate, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryBlock --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("GroupOwned: {0}", GroupOwned));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.Append(String.Format("CRC: {0}", CRC));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RezScript; } }
|
|
public AgentDataBlock AgentData;
|
|
public UpdateBlockBlock UpdateBlock;
|
|
public InventoryBlockBlock InventoryBlock;
|
|
|
|
public RezScriptPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 304;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
UpdateBlock = new UpdateBlockBlock();
|
|
InventoryBlock = new InventoryBlockBlock();
|
|
}
|
|
|
|
public RezScriptPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UpdateBlock.FromBytes(bytes, ref i);
|
|
InventoryBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RezScriptPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UpdateBlock.FromBytes(bytes, ref i);
|
|
InventoryBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += UpdateBlock.Length; length += InventoryBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
UpdateBlock.ToBytes(bytes, ref i);
|
|
InventoryBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RezScript ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += UpdateBlock.ToString() + Environment.NewLine;
|
|
output += InventoryBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateInventoryItemPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryBlockBlock : PacketBlock
|
|
{
|
|
public uint CallbackID;
|
|
public UUID FolderID;
|
|
public UUID TransactionID;
|
|
public uint NextOwnerMask;
|
|
public sbyte Type;
|
|
public sbyte InvType;
|
|
public byte WearableType;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 43;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryBlockBlock() { }
|
|
public InventoryBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
CallbackID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Type = (sbyte)bytes[i++];
|
|
InvType = (sbyte)bytes[i++];
|
|
WearableType = (byte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(CallbackID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)InvType;
|
|
bytes[i++] = WearableType;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryBlock --");
|
|
output.AppendLine(String.Format("CallbackID: {0}", CallbackID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("InvType: {0}", InvType));
|
|
output.AppendLine(String.Format("WearableType: {0}", WearableType));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateInventoryItem; } }
|
|
public AgentDataBlock AgentData;
|
|
public InventoryBlockBlock InventoryBlock;
|
|
|
|
public CreateInventoryItemPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 305;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
InventoryBlock = new InventoryBlockBlock();
|
|
}
|
|
|
|
public CreateInventoryItemPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CreateInventoryItemPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
InventoryBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += InventoryBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
InventoryBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateInventoryItem ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += InventoryBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateLandmarkForEventPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EventDataBlock : PacketBlock
|
|
{
|
|
public uint EventID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public EventDataBlock() { }
|
|
public EventDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EventID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(EventID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EventData --");
|
|
output.Append(String.Format("EventID: {0}", EventID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InventoryBlockBlock : PacketBlock
|
|
{
|
|
public UUID FolderID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public InventoryBlockBlock() { }
|
|
public InventoryBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InventoryBlock --");
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateLandmarkForEvent; } }
|
|
public AgentDataBlock AgentData;
|
|
public EventDataBlock EventData;
|
|
public InventoryBlockBlock InventoryBlock;
|
|
|
|
public CreateLandmarkForEventPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 306;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
EventData = new EventDataBlock();
|
|
InventoryBlock = new InventoryBlockBlock();
|
|
}
|
|
|
|
public CreateLandmarkForEventPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
InventoryBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CreateLandmarkForEventPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
EventData.FromBytes(bytes, ref i);
|
|
InventoryBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += EventData.Length; length += InventoryBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
EventData.ToBytes(bytes, ref i);
|
|
InventoryBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateLandmarkForEvent ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += EventData.ToString() + Environment.NewLine;
|
|
output += InventoryBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionHandleRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RequestBlockBlock : PacketBlock
|
|
{
|
|
public UUID RegionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public RequestBlockBlock() { }
|
|
public RequestBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestBlock --");
|
|
output.Append(String.Format("RegionID: {0}", RegionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RegionHandleRequest; } }
|
|
public RequestBlockBlock RequestBlock;
|
|
|
|
public RegionHandleRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 309;
|
|
Header.Reliable = true;
|
|
RequestBlock = new RequestBlockBlock();
|
|
}
|
|
|
|
public RegionHandleRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RequestBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RegionHandleRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RequestBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += RequestBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RequestBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RegionHandleRequest ---" + Environment.NewLine;
|
|
output += RequestBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionIDAndHandleReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ReplyBlockBlock : PacketBlock
|
|
{
|
|
public UUID RegionID;
|
|
public ulong RegionHandle;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public ReplyBlockBlock() { }
|
|
public ReplyBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionID.FromBytes(bytes, i); i += 16;
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RegionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ReplyBlock --");
|
|
output.AppendLine(String.Format("RegionID: {0}", RegionID));
|
|
output.Append(String.Format("RegionHandle: {0}", RegionHandle));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RegionIDAndHandleReply; } }
|
|
public ReplyBlockBlock ReplyBlock;
|
|
|
|
public RegionIDAndHandleReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 310;
|
|
Header.Reliable = true;
|
|
ReplyBlock = new ReplyBlockBlock();
|
|
}
|
|
|
|
public RegionIDAndHandleReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ReplyBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RegionIDAndHandleReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ReplyBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ReplyBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ReplyBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RegionIDAndHandleReply ---" + Environment.NewLine;
|
|
output += ReplyBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyTransferRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID SourceID;
|
|
public UUID DestID;
|
|
public byte Flags;
|
|
public int Amount;
|
|
public byte AggregatePermNextOwner;
|
|
public byte AggregatePermInventory;
|
|
public int TransactionType;
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 43;
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
SourceID.FromBytes(bytes, i); i += 16;
|
|
DestID.FromBytes(bytes, i); i += 16;
|
|
Flags = (byte)bytes[i++];
|
|
Amount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AggregatePermNextOwner = (byte)bytes[i++];
|
|
AggregatePermInventory = (byte)bytes[i++];
|
|
TransactionType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SourceID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(DestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = Flags;
|
|
Utils.IntToBytes(Amount, bytes, i); i += 4;
|
|
bytes[i++] = AggregatePermNextOwner;
|
|
bytes[i++] = AggregatePermInventory;
|
|
Utils.IntToBytes(TransactionType, bytes, i); i += 4;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("SourceID: {0}", SourceID));
|
|
output.AppendLine(String.Format("DestID: {0}", DestID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("Amount: {0}", Amount));
|
|
output.AppendLine(String.Format("AggregatePermNextOwner: {0}", AggregatePermNextOwner));
|
|
output.AppendLine(String.Format("AggregatePermInventory: {0}", AggregatePermInventory));
|
|
output.AppendLine(String.Format("TransactionType: {0}", TransactionType));
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MoneyTransferRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public MoneyTransferRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 311;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public MoneyTransferRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MoneyTransferRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MoneyTransferRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyBalanceRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MoneyBalanceRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public MoneyBalanceRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 313;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public MoneyBalanceRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MoneyBalanceRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MoneyBalanceRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyBalanceReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID TransactionID;
|
|
public bool TransactionSuccess;
|
|
public int MoneyBalance;
|
|
public int SquareMetersCredit;
|
|
public int SquareMetersCommitted;
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 45;
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
TransactionSuccess = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MoneyBalance = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SquareMetersCredit = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SquareMetersCommitted = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((TransactionSuccess) ? 1 : 0);
|
|
Utils.IntToBytes(MoneyBalance, bytes, i); i += 4;
|
|
Utils.IntToBytes(SquareMetersCredit, bytes, i); i += 4;
|
|
Utils.IntToBytes(SquareMetersCommitted, bytes, i); i += 4;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("TransactionSuccess: {0}", TransactionSuccess));
|
|
output.AppendLine(String.Format("MoneyBalance: {0}", MoneyBalance));
|
|
output.AppendLine(String.Format("SquareMetersCredit: {0}", SquareMetersCredit));
|
|
output.AppendLine(String.Format("SquareMetersCommitted: {0}", SquareMetersCommitted));
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MoneyBalanceReply; } }
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public MoneyBalanceReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 314;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public MoneyBalanceReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MoneyBalanceReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MoneyBalanceReply ---" + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RoutedMoneyBalanceReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TargetBlockBlock : PacketBlock
|
|
{
|
|
public uint TargetIP;
|
|
public ushort TargetPort;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
public TargetBlockBlock() { }
|
|
public TargetBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TargetPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(TargetIP, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((TargetPort >> 8) % 256);
|
|
bytes[i++] = (byte)(TargetPort % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TargetBlock --");
|
|
output.AppendLine(String.Format("TargetIP: {0}", TargetIP));
|
|
output.Append(String.Format("TargetPort: {0}", TargetPort));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID TransactionID;
|
|
public bool TransactionSuccess;
|
|
public int MoneyBalance;
|
|
public int SquareMetersCredit;
|
|
public int SquareMetersCommitted;
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 45;
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
TransactionSuccess = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MoneyBalance = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SquareMetersCredit = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SquareMetersCommitted = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((TransactionSuccess) ? 1 : 0);
|
|
Utils.IntToBytes(MoneyBalance, bytes, i); i += 4;
|
|
Utils.IntToBytes(SquareMetersCredit, bytes, i); i += 4;
|
|
Utils.IntToBytes(SquareMetersCommitted, bytes, i); i += 4;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("TransactionSuccess: {0}", TransactionSuccess));
|
|
output.AppendLine(String.Format("MoneyBalance: {0}", MoneyBalance));
|
|
output.AppendLine(String.Format("SquareMetersCredit: {0}", SquareMetersCredit));
|
|
output.AppendLine(String.Format("SquareMetersCommitted: {0}", SquareMetersCommitted));
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RoutedMoneyBalanceReply; } }
|
|
public TargetBlockBlock TargetBlock;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public RoutedMoneyBalanceReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 315;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
TargetBlock = new TargetBlockBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public RoutedMoneyBalanceReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TargetBlock.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RoutedMoneyBalanceReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TargetBlock.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += TargetBlock.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TargetBlock.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RoutedMoneyBalanceReply ---" + Environment.NewLine;
|
|
output += TargetBlock.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ActivateGesturesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID AssetID;
|
|
public uint GestureFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
GestureFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(GestureFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.Append(String.Format("GestureFlags: {0}", GestureFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ActivateGestures; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public ActivateGesturesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 316;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public ActivateGesturesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ActivateGesturesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ActivateGestures ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DeactivateGesturesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public uint GestureFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
GestureFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(GestureFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("GestureFlags: {0}", GestureFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DeactivateGestures; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public DeactivateGesturesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 317;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public DeactivateGesturesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public DeactivateGesturesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DeactivateGestures ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MuteListUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class MuteDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
private byte[] _filename;
|
|
public byte[] Filename
|
|
{
|
|
get { return _filename; }
|
|
set
|
|
{
|
|
if (value == null) { _filename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _filename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filename, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 16;
|
|
if (Filename != null) { length += 1 + Filename.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MuteDataBlock() { }
|
|
public MuteDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_filename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _filename, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Filename == null) { Console.WriteLine("Warning: Filename is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Filename.Length;
|
|
Buffer.BlockCopy(Filename, 0, bytes, i, Filename.Length); i += Filename.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MuteData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
Helpers.FieldToString(output, Filename, "Filename");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MuteListUpdate; } }
|
|
public MuteDataBlock MuteData;
|
|
|
|
public MuteListUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 318;
|
|
Header.Reliable = true;
|
|
MuteData = new MuteDataBlock();
|
|
}
|
|
|
|
public MuteListUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MuteListUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
MuteData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += MuteData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
MuteData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MuteListUpdate ---" + Environment.NewLine;
|
|
output += MuteData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UseCachedMuteListPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UseCachedMuteList; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public UseCachedMuteListPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 319;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public UseCachedMuteListPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UseCachedMuteListPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UseCachedMuteList ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GrantUserRightsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RightsBlock : PacketBlock
|
|
{
|
|
public UUID AgentRelated;
|
|
public int RelatedRights;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public RightsBlock() { }
|
|
public RightsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentRelated.FromBytes(bytes, i); i += 16;
|
|
RelatedRights = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentRelated.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(RelatedRights, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Rights --");
|
|
output.AppendLine(String.Format("AgentRelated: {0}", AgentRelated));
|
|
output.Append(String.Format("RelatedRights: {0}", RelatedRights));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GrantUserRights; } }
|
|
public AgentDataBlock AgentData;
|
|
public RightsBlock[] Rights;
|
|
|
|
public GrantUserRightsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 320;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Rights = new RightsBlock[0];
|
|
}
|
|
|
|
public GrantUserRightsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Rights.Length < count) {
|
|
Rights = new RightsBlock[count];
|
|
for(int j = 0; j < count; j++) Rights[j] = new RightsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Rights[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GrantUserRightsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Rights.Length < count) {
|
|
Rights = new RightsBlock[count];
|
|
for(int j = 0; j < count; j++) Rights[j] = new RightsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Rights[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Rights.Length; j++) { length += Rights[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Rights.Length;
|
|
for (int j = 0; j < Rights.Length; j++) { Rights[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GrantUserRights ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Rights.Length; j++)
|
|
{
|
|
output += Rights[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChangeUserRightsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RightsBlock : PacketBlock
|
|
{
|
|
public UUID AgentRelated;
|
|
public int RelatedRights;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public RightsBlock() { }
|
|
public RightsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentRelated.FromBytes(bytes, i); i += 16;
|
|
RelatedRights = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentRelated.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(RelatedRights, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Rights --");
|
|
output.AppendLine(String.Format("AgentRelated: {0}", AgentRelated));
|
|
output.Append(String.Format("RelatedRights: {0}", RelatedRights));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChangeUserRights; } }
|
|
public AgentDataBlock AgentData;
|
|
public RightsBlock[] Rights;
|
|
|
|
public ChangeUserRightsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 321;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Rights = new RightsBlock[0];
|
|
}
|
|
|
|
public ChangeUserRightsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Rights.Length < count) {
|
|
Rights = new RightsBlock[count];
|
|
for(int j = 0; j < count; j++) Rights[j] = new RightsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Rights[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ChangeUserRightsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Rights.Length < count) {
|
|
Rights = new RightsBlock[count];
|
|
for(int j = 0; j < count; j++) Rights[j] = new RightsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Rights[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Rights.Length; j++) { length += Rights[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Rights.Length;
|
|
for (int j = 0; j < Rights.Length; j++) { Rights[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChangeUserRights ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Rights.Length; j++)
|
|
{
|
|
output += Rights[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class OnlineNotificationPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentBlockBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentBlockBlock() { }
|
|
public AgentBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentBlock --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.OnlineNotification; } }
|
|
public AgentBlockBlock[] AgentBlock;
|
|
|
|
public OnlineNotificationPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 322;
|
|
Header.Reliable = true;
|
|
AgentBlock = new AgentBlockBlock[0];
|
|
}
|
|
|
|
public OnlineNotificationPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(AgentBlock.Length < count) {
|
|
AgentBlock = new AgentBlockBlock[count];
|
|
for(int j = 0; j < count; j++) AgentBlock[j] = new AgentBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public OnlineNotificationPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(AgentBlock.Length < count) {
|
|
AgentBlock = new AgentBlockBlock[count];
|
|
for(int j = 0; j < count; j++) AgentBlock[j] = new AgentBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < AgentBlock.Length; j++) { length += AgentBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)AgentBlock.Length;
|
|
for (int j = 0; j < AgentBlock.Length; j++) { AgentBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- OnlineNotification ---" + Environment.NewLine;
|
|
for (int j = 0; j < AgentBlock.Length; j++)
|
|
{
|
|
output += AgentBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class OfflineNotificationPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentBlockBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentBlockBlock() { }
|
|
public AgentBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentBlock --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.OfflineNotification; } }
|
|
public AgentBlockBlock[] AgentBlock;
|
|
|
|
public OfflineNotificationPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 323;
|
|
Header.Reliable = true;
|
|
AgentBlock = new AgentBlockBlock[0];
|
|
}
|
|
|
|
public OfflineNotificationPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(AgentBlock.Length < count) {
|
|
AgentBlock = new AgentBlockBlock[count];
|
|
for(int j = 0; j < count; j++) AgentBlock[j] = new AgentBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public OfflineNotificationPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(AgentBlock.Length < count) {
|
|
AgentBlock = new AgentBlockBlock[count];
|
|
for(int j = 0; j < count; j++) AgentBlock[j] = new AgentBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < AgentBlock.Length; j++) { length += AgentBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)AgentBlock.Length;
|
|
for (int j = 0; j < AgentBlock.Length; j++) { AgentBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- OfflineNotification ---" + Environment.NewLine;
|
|
for (int j = 0; j < AgentBlock.Length; j++)
|
|
{
|
|
output += AgentBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SetStartLocationRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class StartLocationDataBlock : PacketBlock
|
|
{
|
|
private byte[] _simname;
|
|
public byte[] SimName
|
|
{
|
|
get { return _simname; }
|
|
set
|
|
{
|
|
if (value == null) { _simname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simname, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint LocationID;
|
|
public Vector3 LocationPos;
|
|
public Vector3 LocationLookAt;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (SimName != null) { length += 1 + SimName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public StartLocationDataBlock() { }
|
|
public StartLocationDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_simname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simname, 0, length); i += length;
|
|
LocationID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LocationPos.FromBytes(bytes, i); i += 12;
|
|
LocationLookAt.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(SimName == null) { Console.WriteLine("Warning: SimName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimName.Length;
|
|
Buffer.BlockCopy(SimName, 0, bytes, i, SimName.Length); i += SimName.Length;
|
|
Utils.UIntToBytes(LocationID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(LocationPos.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LocationLookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- StartLocationData --");
|
|
Helpers.FieldToString(output, SimName, "SimName");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("LocationID: {0}", LocationID));
|
|
output.AppendLine(String.Format("LocationPos: {0}", LocationPos));
|
|
output.Append(String.Format("LocationLookAt: {0}", LocationLookAt));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SetStartLocationRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public StartLocationDataBlock StartLocationData;
|
|
|
|
public SetStartLocationRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 324;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
StartLocationData = new StartLocationDataBlock();
|
|
}
|
|
|
|
public SetStartLocationRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
StartLocationData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SetStartLocationRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
StartLocationData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += StartLocationData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
StartLocationData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SetStartLocationRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += StartLocationData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AssetUploadRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AssetBlockBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
public sbyte Type;
|
|
public bool Tempfile;
|
|
public bool StoreLocal;
|
|
private byte[] _assetdata;
|
|
public byte[] AssetData
|
|
{
|
|
get { return _assetdata; }
|
|
set
|
|
{
|
|
if (value == null) { _assetdata = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _assetdata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _assetdata, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 19;
|
|
if (AssetData != null) { length += 2 + AssetData.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AssetBlockBlock() { }
|
|
public AssetBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
Tempfile = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
StoreLocal = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_assetdata = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _assetdata, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)((Tempfile) ? 1 : 0);
|
|
bytes[i++] = (byte)((StoreLocal) ? 1 : 0);
|
|
if(AssetData == null) { Console.WriteLine("Warning: AssetData is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(AssetData.Length % 256);
|
|
bytes[i++] = (byte)((AssetData.Length >> 8) % 256);
|
|
Buffer.BlockCopy(AssetData, 0, bytes, i, AssetData.Length); i += AssetData.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AssetBlock --");
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("Tempfile: {0}", Tempfile));
|
|
output.AppendLine(String.Format("StoreLocal: {0}", StoreLocal));
|
|
Helpers.FieldToString(output, AssetData, "AssetData");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AssetUploadRequest; } }
|
|
public AssetBlockBlock AssetBlock;
|
|
|
|
public AssetUploadRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 333;
|
|
Header.Reliable = true;
|
|
AssetBlock = new AssetBlockBlock();
|
|
}
|
|
|
|
public AssetUploadRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AssetBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AssetUploadRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AssetBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AssetBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AssetBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AssetUploadRequest ---" + Environment.NewLine;
|
|
output += AssetBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AssetUploadCompletePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AssetBlockBlock : PacketBlock
|
|
{
|
|
public UUID UUID;
|
|
public sbyte Type;
|
|
public bool Success;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 18;
|
|
}
|
|
}
|
|
|
|
public AssetBlockBlock() { }
|
|
public AssetBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
UUID.FromBytes(bytes, i); i += 16;
|
|
Type = (sbyte)bytes[i++];
|
|
Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(UUID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)Type;
|
|
bytes[i++] = (byte)((Success) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AssetBlock --");
|
|
output.AppendLine(String.Format("UUID: {0}", UUID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.Append(String.Format("Success: {0}", Success));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AssetUploadComplete; } }
|
|
public AssetBlockBlock AssetBlock;
|
|
|
|
public AssetUploadCompletePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 334;
|
|
Header.Reliable = true;
|
|
AssetBlock = new AssetBlockBlock();
|
|
}
|
|
|
|
public AssetUploadCompletePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AssetBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AssetUploadCompletePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AssetBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AssetBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AssetBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AssetUploadComplete ---" + Environment.NewLine;
|
|
output += AssetBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateGroupRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _charter;
|
|
public byte[] Charter
|
|
{
|
|
get { return _charter; }
|
|
set
|
|
{
|
|
if (value == null) { _charter = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _charter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _charter, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool ShowInList;
|
|
public UUID InsigniaID;
|
|
public int MembershipFee;
|
|
public bool OpenEnrollment;
|
|
public bool AllowPublish;
|
|
public bool MaturePublish;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Charter != null) { length += 2 + Charter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_charter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _charter, 0, length); i += length;
|
|
ShowInList = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
InsigniaID.FromBytes(bytes, i); i += 16;
|
|
MembershipFee = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OpenEnrollment = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Charter == null) { Console.WriteLine("Warning: Charter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Charter.Length % 256);
|
|
bytes[i++] = (byte)((Charter.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Charter, 0, bytes, i, Charter.Length); i += Charter.Length;
|
|
bytes[i++] = (byte)((ShowInList) ? 1 : 0);
|
|
Buffer.BlockCopy(InsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(MembershipFee, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((OpenEnrollment) ? 1 : 0);
|
|
bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
|
|
bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Charter, "Charter");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ShowInList: {0}", ShowInList));
|
|
output.AppendLine(String.Format("InsigniaID: {0}", InsigniaID));
|
|
output.AppendLine(String.Format("MembershipFee: {0}", MembershipFee));
|
|
output.AppendLine(String.Format("OpenEnrollment: {0}", OpenEnrollment));
|
|
output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
|
|
output.Append(String.Format("MaturePublish: {0}", MaturePublish));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateGroupRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public CreateGroupRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 339;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public CreateGroupRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CreateGroupRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateGroupRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateGroupReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ReplyDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public bool Success;
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 17;
|
|
if (Message != null) { length += 1 + Message.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ReplyDataBlock() { }
|
|
public ReplyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Success) ? 1 : 0);
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Message.Length;
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ReplyData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("Success: {0}", Success));
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateGroupReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public ReplyDataBlock ReplyData;
|
|
|
|
public CreateGroupReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 340;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ReplyData = new ReplyDataBlock();
|
|
}
|
|
|
|
public CreateGroupReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ReplyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CreateGroupReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ReplyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ReplyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ReplyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateGroupReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ReplyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateGroupInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
private byte[] _charter;
|
|
public byte[] Charter
|
|
{
|
|
get { return _charter; }
|
|
set
|
|
{
|
|
if (value == null) { _charter = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _charter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _charter, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool ShowInList;
|
|
public UUID InsigniaID;
|
|
public int MembershipFee;
|
|
public bool OpenEnrollment;
|
|
public bool AllowPublish;
|
|
public bool MaturePublish;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 40;
|
|
if (Charter != null) { length += 2 + Charter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_charter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _charter, 0, length); i += length;
|
|
ShowInList = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
InsigniaID.FromBytes(bytes, i); i += 16;
|
|
MembershipFee = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OpenEnrollment = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Charter == null) { Console.WriteLine("Warning: Charter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Charter.Length % 256);
|
|
bytes[i++] = (byte)((Charter.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Charter, 0, bytes, i, Charter.Length); i += Charter.Length;
|
|
bytes[i++] = (byte)((ShowInList) ? 1 : 0);
|
|
Buffer.BlockCopy(InsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(MembershipFee, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((OpenEnrollment) ? 1 : 0);
|
|
bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
|
|
bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
Helpers.FieldToString(output, Charter, "Charter");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ShowInList: {0}", ShowInList));
|
|
output.AppendLine(String.Format("InsigniaID: {0}", InsigniaID));
|
|
output.AppendLine(String.Format("MembershipFee: {0}", MembershipFee));
|
|
output.AppendLine(String.Format("OpenEnrollment: {0}", OpenEnrollment));
|
|
output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
|
|
output.Append(String.Format("MaturePublish: {0}", MaturePublish));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateGroupInfo; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public UpdateGroupInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 341;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public UpdateGroupInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UpdateGroupInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateGroupInfo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupRoleChangesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RoleChangeBlock : PacketBlock
|
|
{
|
|
public UUID RoleID;
|
|
public UUID MemberID;
|
|
public uint Change;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public RoleChangeBlock() { }
|
|
public RoleChangeBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RoleID.FromBytes(bytes, i); i += 16;
|
|
MemberID.FromBytes(bytes, i); i += 16;
|
|
Change = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(MemberID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Change, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RoleChange --");
|
|
output.AppendLine(String.Format("RoleID: {0}", RoleID));
|
|
output.AppendLine(String.Format("MemberID: {0}", MemberID));
|
|
output.Append(String.Format("Change: {0}", Change));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupRoleChanges; } }
|
|
public AgentDataBlock AgentData;
|
|
public RoleChangeBlock[] RoleChange;
|
|
|
|
public GroupRoleChangesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 342;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RoleChange = new RoleChangeBlock[0];
|
|
}
|
|
|
|
public GroupRoleChangesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RoleChange.Length < count) {
|
|
RoleChange = new RoleChangeBlock[count];
|
|
for(int j = 0; j < count; j++) RoleChange[j] = new RoleChangeBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RoleChange[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupRoleChangesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RoleChange.Length < count) {
|
|
RoleChange = new RoleChangeBlock[count];
|
|
for(int j = 0; j < count; j++) RoleChange[j] = new RoleChangeBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RoleChange[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < RoleChange.Length; j++) { length += RoleChange[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)RoleChange.Length;
|
|
for (int j = 0; j < RoleChange.Length; j++) { RoleChange[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupRoleChanges ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < RoleChange.Length; j++)
|
|
{
|
|
output += RoleChange[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class JoinGroupRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.JoinGroupRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public JoinGroupRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 343;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public JoinGroupRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public JoinGroupRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- JoinGroupRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class JoinGroupReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public bool Success;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Success) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("Success: {0}", Success));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.JoinGroupReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public JoinGroupReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 344;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public JoinGroupReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public JoinGroupReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- JoinGroupReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EjectGroupMemberRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EjectDataBlock : PacketBlock
|
|
{
|
|
public UUID EjecteeID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public EjectDataBlock() { }
|
|
public EjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EjecteeID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(EjecteeID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EjectData --");
|
|
output.Append(String.Format("EjecteeID: {0}", EjecteeID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EjectGroupMemberRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public EjectDataBlock[] EjectData;
|
|
|
|
public EjectGroupMemberRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 345;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
EjectData = new EjectDataBlock[0];
|
|
}
|
|
|
|
public EjectGroupMemberRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(EjectData.Length < count) {
|
|
EjectData = new EjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) EjectData[j] = new EjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ EjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public EjectGroupMemberRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(EjectData.Length < count) {
|
|
EjectData = new EjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) EjectData[j] = new EjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ EjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
length++;
|
|
for (int j = 0; j < EjectData.Length; j++) { length += EjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)EjectData.Length;
|
|
for (int j = 0; j < EjectData.Length; j++) { EjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EjectGroupMemberRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < EjectData.Length; j++)
|
|
{
|
|
output += EjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EjectGroupMemberReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EjectDataBlock : PacketBlock
|
|
{
|
|
public bool Success;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public EjectDataBlock() { }
|
|
public EjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((Success) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- EjectData --");
|
|
output.Append(String.Format("Success: {0}", Success));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.EjectGroupMemberReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public EjectDataBlock EjectData;
|
|
|
|
public EjectGroupMemberReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 346;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
EjectData = new EjectDataBlock();
|
|
}
|
|
|
|
public EjectGroupMemberReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
EjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public EjectGroupMemberReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
EjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length; length += EjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
EjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- EjectGroupMemberReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
output += EjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LeaveGroupRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LeaveGroupRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public LeaveGroupRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 347;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public LeaveGroupRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LeaveGroupRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LeaveGroupRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LeaveGroupReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public bool Success;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Success = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Success) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("Success: {0}", Success));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LeaveGroupReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public LeaveGroupReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 348;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public LeaveGroupReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LeaveGroupReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LeaveGroupReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InviteGroupRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InviteDataBlock : PacketBlock
|
|
{
|
|
public UUID InviteeID;
|
|
public UUID RoleID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public InviteDataBlock() { }
|
|
public InviteDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
InviteeID.FromBytes(bytes, i); i += 16;
|
|
RoleID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(InviteeID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- InviteData --");
|
|
output.AppendLine(String.Format("InviteeID: {0}", InviteeID));
|
|
output.Append(String.Format("RoleID: {0}", RoleID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.InviteGroupRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public InviteDataBlock[] InviteData;
|
|
|
|
public InviteGroupRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 349;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
InviteData = new InviteDataBlock[0];
|
|
}
|
|
|
|
public InviteGroupRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InviteData.Length < count) {
|
|
InviteData = new InviteDataBlock[count];
|
|
for(int j = 0; j < count; j++) InviteData[j] = new InviteDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InviteData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public InviteGroupRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(InviteData.Length < count) {
|
|
InviteData = new InviteDataBlock[count];
|
|
for(int j = 0; j < count; j++) InviteData[j] = new InviteDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ InviteData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
length++;
|
|
for (int j = 0; j < InviteData.Length; j++) { length += InviteData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)InviteData.Length;
|
|
for (int j = 0; j < InviteData.Length; j++) { InviteData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- InviteGroupRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < InviteData.Length; j++)
|
|
{
|
|
output += InviteData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupProfileRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupProfileRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public GroupProfileRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 351;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public GroupProfileRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupProfileRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupProfileRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupProfileReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _charter;
|
|
public byte[] Charter
|
|
{
|
|
get { return _charter; }
|
|
set
|
|
{
|
|
if (value == null) { _charter = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _charter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _charter, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool ShowInList;
|
|
private byte[] _membertitle;
|
|
public byte[] MemberTitle
|
|
{
|
|
get { return _membertitle; }
|
|
set
|
|
{
|
|
if (value == null) { _membertitle = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _membertitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _membertitle, 0, value.Length); }
|
|
}
|
|
}
|
|
public ulong PowersMask;
|
|
public UUID InsigniaID;
|
|
public UUID FounderID;
|
|
public int MembershipFee;
|
|
public bool OpenEnrollment;
|
|
public int Money;
|
|
public int GroupMembershipCount;
|
|
public int GroupRolesCount;
|
|
public bool AllowPublish;
|
|
public bool MaturePublish;
|
|
public UUID OwnerRole;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 92;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Charter != null) { length += 2 + Charter.Length; }
|
|
if (MemberTitle != null) { length += 1 + MemberTitle.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_charter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _charter, 0, length); i += length;
|
|
ShowInList = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_membertitle = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _membertitle, 0, length); i += length;
|
|
PowersMask = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
InsigniaID.FromBytes(bytes, i); i += 16;
|
|
FounderID.FromBytes(bytes, i); i += 16;
|
|
MembershipFee = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OpenEnrollment = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Money = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMembershipCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupRolesCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
OwnerRole.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Charter == null) { Console.WriteLine("Warning: Charter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Charter.Length % 256);
|
|
bytes[i++] = (byte)((Charter.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Charter, 0, bytes, i, Charter.Length); i += Charter.Length;
|
|
bytes[i++] = (byte)((ShowInList) ? 1 : 0);
|
|
if(MemberTitle == null) { Console.WriteLine("Warning: MemberTitle is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MemberTitle.Length;
|
|
Buffer.BlockCopy(MemberTitle, 0, bytes, i, MemberTitle.Length); i += MemberTitle.Length;
|
|
Utils.UInt64ToBytes(PowersMask, bytes, i); i += 8;
|
|
Buffer.BlockCopy(InsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FounderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(MembershipFee, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((OpenEnrollment) ? 1 : 0);
|
|
Utils.IntToBytes(Money, bytes, i); i += 4;
|
|
Utils.IntToBytes(GroupMembershipCount, bytes, i); i += 4;
|
|
Utils.IntToBytes(GroupRolesCount, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
|
|
bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
|
|
Buffer.BlockCopy(OwnerRole.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Charter, "Charter");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ShowInList: {0}", ShowInList));
|
|
Helpers.FieldToString(output, MemberTitle, "MemberTitle");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("PowersMask: {0}", PowersMask));
|
|
output.AppendLine(String.Format("InsigniaID: {0}", InsigniaID));
|
|
output.AppendLine(String.Format("FounderID: {0}", FounderID));
|
|
output.AppendLine(String.Format("MembershipFee: {0}", MembershipFee));
|
|
output.AppendLine(String.Format("OpenEnrollment: {0}", OpenEnrollment));
|
|
output.AppendLine(String.Format("Money: {0}", Money));
|
|
output.AppendLine(String.Format("GroupMembershipCount: {0}", GroupMembershipCount));
|
|
output.AppendLine(String.Format("GroupRolesCount: {0}", GroupRolesCount));
|
|
output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
|
|
output.AppendLine(String.Format("MaturePublish: {0}", MaturePublish));
|
|
output.Append(String.Format("OwnerRole: {0}", OwnerRole));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupProfileReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public GroupProfileReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 352;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public GroupProfileReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupProfileReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupProfileReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupAccountSummaryRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public int IntervalDays;
|
|
public int CurrentInterval;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(IntervalDays, bytes, i); i += 4;
|
|
Utils.IntToBytes(CurrentInterval, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
|
|
output.Append(String.Format("CurrentInterval: {0}", CurrentInterval));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupAccountSummaryRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public GroupAccountSummaryRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 353;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public GroupAccountSummaryRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupAccountSummaryRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupAccountSummaryRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupAccountSummaryReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public int IntervalDays;
|
|
public int CurrentInterval;
|
|
private byte[] _startdate;
|
|
public byte[] StartDate
|
|
{
|
|
get { return _startdate; }
|
|
set
|
|
{
|
|
if (value == null) { _startdate = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _startdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdate, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Balance;
|
|
public int TotalCredits;
|
|
public int TotalDebits;
|
|
public int ObjectTaxCurrent;
|
|
public int LightTaxCurrent;
|
|
public int LandTaxCurrent;
|
|
public int GroupTaxCurrent;
|
|
public int ParcelDirFeeCurrent;
|
|
public int ObjectTaxEstimate;
|
|
public int LightTaxEstimate;
|
|
public int LandTaxEstimate;
|
|
public int GroupTaxEstimate;
|
|
public int ParcelDirFeeEstimate;
|
|
public int NonExemptMembers;
|
|
private byte[] _lasttaxdate;
|
|
public byte[] LastTaxDate
|
|
{
|
|
get { return _lasttaxdate; }
|
|
set
|
|
{
|
|
if (value == null) { _lasttaxdate = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _lasttaxdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lasttaxdate, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _taxdate;
|
|
public byte[] TaxDate
|
|
{
|
|
get { return _taxdate; }
|
|
set
|
|
{
|
|
if (value == null) { _taxdate = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _taxdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _taxdate, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 80;
|
|
if (StartDate != null) { length += 1 + StartDate.Length; }
|
|
if (LastTaxDate != null) { length += 1 + LastTaxDate.Length; }
|
|
if (TaxDate != null) { length += 1 + TaxDate.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_startdate = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _startdate, 0, length); i += length;
|
|
Balance = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TotalCredits = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TotalDebits = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ObjectTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LightTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LandTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupTaxCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelDirFeeCurrent = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ObjectTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LightTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LandTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupTaxEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelDirFeeEstimate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NonExemptMembers = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_lasttaxdate = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _lasttaxdate, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_taxdate = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _taxdate, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(IntervalDays, bytes, i); i += 4;
|
|
Utils.IntToBytes(CurrentInterval, bytes, i); i += 4;
|
|
if(StartDate == null) { Console.WriteLine("Warning: StartDate is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)StartDate.Length;
|
|
Buffer.BlockCopy(StartDate, 0, bytes, i, StartDate.Length); i += StartDate.Length;
|
|
Utils.IntToBytes(Balance, bytes, i); i += 4;
|
|
Utils.IntToBytes(TotalCredits, bytes, i); i += 4;
|
|
Utils.IntToBytes(TotalDebits, bytes, i); i += 4;
|
|
Utils.IntToBytes(ObjectTaxCurrent, bytes, i); i += 4;
|
|
Utils.IntToBytes(LightTaxCurrent, bytes, i); i += 4;
|
|
Utils.IntToBytes(LandTaxCurrent, bytes, i); i += 4;
|
|
Utils.IntToBytes(GroupTaxCurrent, bytes, i); i += 4;
|
|
Utils.IntToBytes(ParcelDirFeeCurrent, bytes, i); i += 4;
|
|
Utils.IntToBytes(ObjectTaxEstimate, bytes, i); i += 4;
|
|
Utils.IntToBytes(LightTaxEstimate, bytes, i); i += 4;
|
|
Utils.IntToBytes(LandTaxEstimate, bytes, i); i += 4;
|
|
Utils.IntToBytes(GroupTaxEstimate, bytes, i); i += 4;
|
|
Utils.IntToBytes(ParcelDirFeeEstimate, bytes, i); i += 4;
|
|
Utils.IntToBytes(NonExemptMembers, bytes, i); i += 4;
|
|
if(LastTaxDate == null) { Console.WriteLine("Warning: LastTaxDate is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LastTaxDate.Length;
|
|
Buffer.BlockCopy(LastTaxDate, 0, bytes, i, LastTaxDate.Length); i += LastTaxDate.Length;
|
|
if(TaxDate == null) { Console.WriteLine("Warning: TaxDate is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TaxDate.Length;
|
|
Buffer.BlockCopy(TaxDate, 0, bytes, i, TaxDate.Length); i += TaxDate.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
|
|
output.AppendLine(String.Format("CurrentInterval: {0}", CurrentInterval));
|
|
Helpers.FieldToString(output, StartDate, "StartDate");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Balance: {0}", Balance));
|
|
output.AppendLine(String.Format("TotalCredits: {0}", TotalCredits));
|
|
output.AppendLine(String.Format("TotalDebits: {0}", TotalDebits));
|
|
output.AppendLine(String.Format("ObjectTaxCurrent: {0}", ObjectTaxCurrent));
|
|
output.AppendLine(String.Format("LightTaxCurrent: {0}", LightTaxCurrent));
|
|
output.AppendLine(String.Format("LandTaxCurrent: {0}", LandTaxCurrent));
|
|
output.AppendLine(String.Format("GroupTaxCurrent: {0}", GroupTaxCurrent));
|
|
output.AppendLine(String.Format("ParcelDirFeeCurrent: {0}", ParcelDirFeeCurrent));
|
|
output.AppendLine(String.Format("ObjectTaxEstimate: {0}", ObjectTaxEstimate));
|
|
output.AppendLine(String.Format("LightTaxEstimate: {0}", LightTaxEstimate));
|
|
output.AppendLine(String.Format("LandTaxEstimate: {0}", LandTaxEstimate));
|
|
output.AppendLine(String.Format("GroupTaxEstimate: {0}", GroupTaxEstimate));
|
|
output.AppendLine(String.Format("ParcelDirFeeEstimate: {0}", ParcelDirFeeEstimate));
|
|
output.AppendLine(String.Format("NonExemptMembers: {0}", NonExemptMembers));
|
|
Helpers.FieldToString(output, LastTaxDate, "LastTaxDate");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TaxDate, "TaxDate");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupAccountSummaryReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public GroupAccountSummaryReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 354;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public GroupAccountSummaryReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupAccountSummaryReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupAccountSummaryReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupAccountDetailsRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public int IntervalDays;
|
|
public int CurrentInterval;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(IntervalDays, bytes, i); i += 4;
|
|
Utils.IntToBytes(CurrentInterval, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
|
|
output.Append(String.Format("CurrentInterval: {0}", CurrentInterval));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupAccountDetailsRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public GroupAccountDetailsRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 355;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public GroupAccountDetailsRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupAccountDetailsRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupAccountDetailsRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupAccountDetailsReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public int IntervalDays;
|
|
public int CurrentInterval;
|
|
private byte[] _startdate;
|
|
public byte[] StartDate
|
|
{
|
|
get { return _startdate; }
|
|
set
|
|
{
|
|
if (value == null) { _startdate = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _startdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdate, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (StartDate != null) { length += 1 + StartDate.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_startdate = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _startdate, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(IntervalDays, bytes, i); i += 4;
|
|
Utils.IntToBytes(CurrentInterval, bytes, i); i += 4;
|
|
if(StartDate == null) { Console.WriteLine("Warning: StartDate is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)StartDate.Length;
|
|
Buffer.BlockCopy(StartDate, 0, bytes, i, StartDate.Length); i += StartDate.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
|
|
output.AppendLine(String.Format("CurrentInterval: {0}", CurrentInterval));
|
|
Helpers.FieldToString(output, StartDate, "StartDate");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HistoryDataBlock : PacketBlock
|
|
{
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Amount;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public HistoryDataBlock() { }
|
|
public HistoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
Amount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.IntToBytes(Amount, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HistoryData --");
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Amount: {0}", Amount));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupAccountDetailsReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
public HistoryDataBlock[] HistoryData;
|
|
|
|
public GroupAccountDetailsReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 356;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
HistoryData = new HistoryDataBlock[0];
|
|
}
|
|
|
|
public GroupAccountDetailsReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(HistoryData.Length < count) {
|
|
HistoryData = new HistoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) HistoryData[j] = new HistoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ HistoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupAccountDetailsReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(HistoryData.Length < count) {
|
|
HistoryData = new HistoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) HistoryData[j] = new HistoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ HistoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
length++;
|
|
for (int j = 0; j < HistoryData.Length; j++) { length += HistoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)HistoryData.Length;
|
|
for (int j = 0; j < HistoryData.Length; j++) { HistoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupAccountDetailsReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < HistoryData.Length; j++)
|
|
{
|
|
output += HistoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupAccountTransactionsRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public int IntervalDays;
|
|
public int CurrentInterval;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(IntervalDays, bytes, i); i += 4;
|
|
Utils.IntToBytes(CurrentInterval, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
|
|
output.Append(String.Format("CurrentInterval: {0}", CurrentInterval));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupAccountTransactionsRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
|
|
public GroupAccountTransactionsRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 357;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
}
|
|
|
|
public GroupAccountTransactionsRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupAccountTransactionsRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupAccountTransactionsRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupAccountTransactionsReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MoneyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public int IntervalDays;
|
|
public int CurrentInterval;
|
|
private byte[] _startdate;
|
|
public byte[] StartDate
|
|
{
|
|
get { return _startdate; }
|
|
set
|
|
{
|
|
if (value == null) { _startdate = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _startdate = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdate, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 24;
|
|
if (StartDate != null) { length += 1 + StartDate.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MoneyDataBlock() { }
|
|
public MoneyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
IntervalDays = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CurrentInterval = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_startdate = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _startdate, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(IntervalDays, bytes, i); i += 4;
|
|
Utils.IntToBytes(CurrentInterval, bytes, i); i += 4;
|
|
if(StartDate == null) { Console.WriteLine("Warning: StartDate is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)StartDate.Length;
|
|
Buffer.BlockCopy(StartDate, 0, bytes, i, StartDate.Length); i += StartDate.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MoneyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("IntervalDays: {0}", IntervalDays));
|
|
output.AppendLine(String.Format("CurrentInterval: {0}", CurrentInterval));
|
|
Helpers.FieldToString(output, StartDate, "StartDate");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HistoryDataBlock : PacketBlock
|
|
{
|
|
private byte[] _time;
|
|
public byte[] Time
|
|
{
|
|
get { return _time; }
|
|
set
|
|
{
|
|
if (value == null) { _time = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _time = new byte[value.Length]; Buffer.BlockCopy(value, 0, _time, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _user;
|
|
public byte[] User
|
|
{
|
|
get { return _user; }
|
|
set
|
|
{
|
|
if (value == null) { _user = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _user = new byte[value.Length]; Buffer.BlockCopy(value, 0, _user, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Type;
|
|
private byte[] _item;
|
|
public byte[] Item
|
|
{
|
|
get { return _item; }
|
|
set
|
|
{
|
|
if (value == null) { _item = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _item = new byte[value.Length]; Buffer.BlockCopy(value, 0, _item, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Amount;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 8;
|
|
if (Time != null) { length += 1 + Time.Length; }
|
|
if (User != null) { length += 1 + User.Length; }
|
|
if (Item != null) { length += 1 + Item.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public HistoryDataBlock() { }
|
|
public HistoryDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_time = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _time, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_user = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _user, 0, length); i += length;
|
|
Type = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_item = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _item, 0, length); i += length;
|
|
Amount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Time == null) { Console.WriteLine("Warning: Time is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Time.Length;
|
|
Buffer.BlockCopy(Time, 0, bytes, i, Time.Length); i += Time.Length;
|
|
if(User == null) { Console.WriteLine("Warning: User is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)User.Length;
|
|
Buffer.BlockCopy(User, 0, bytes, i, User.Length); i += User.Length;
|
|
Utils.IntToBytes(Type, bytes, i); i += 4;
|
|
if(Item == null) { Console.WriteLine("Warning: Item is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Item.Length;
|
|
Buffer.BlockCopy(Item, 0, bytes, i, Item.Length); i += Item.Length;
|
|
Utils.IntToBytes(Amount, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HistoryData --");
|
|
Helpers.FieldToString(output, Time, "Time");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, User, "User");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
Helpers.FieldToString(output, Item, "Item");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("Amount: {0}", Amount));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupAccountTransactionsReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public MoneyDataBlock MoneyData;
|
|
public HistoryDataBlock[] HistoryData;
|
|
|
|
public GroupAccountTransactionsReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 358;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
MoneyData = new MoneyDataBlock();
|
|
HistoryData = new HistoryDataBlock[0];
|
|
}
|
|
|
|
public GroupAccountTransactionsReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(HistoryData.Length < count) {
|
|
HistoryData = new HistoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) HistoryData[j] = new HistoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ HistoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupAccountTransactionsReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
MoneyData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(HistoryData.Length < count) {
|
|
HistoryData = new HistoryDataBlock[count];
|
|
for(int j = 0; j < count; j++) HistoryData[j] = new HistoryDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ HistoryData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += MoneyData.Length;;
|
|
length++;
|
|
for (int j = 0; j < HistoryData.Length; j++) { length += HistoryData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
MoneyData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)HistoryData.Length;
|
|
for (int j = 0; j < HistoryData.Length; j++) { HistoryData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupAccountTransactionsReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += MoneyData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < HistoryData.Length; j++)
|
|
{
|
|
output += HistoryData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupActiveProposalsRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupActiveProposalsRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public TransactionDataBlock TransactionData;
|
|
|
|
public GroupActiveProposalsRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 359;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
TransactionData = new TransactionDataBlock();
|
|
}
|
|
|
|
public GroupActiveProposalsRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupActiveProposalsRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length; length += TransactionData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupActiveProposalsRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupActiveProposalItemReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
public uint TotalNumItems;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
TotalNumItems = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(TotalNumItems, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.Append(String.Format("TotalNumItems: {0}", TotalNumItems));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ProposalDataBlock : PacketBlock
|
|
{
|
|
public UUID VoteID;
|
|
public UUID VoteInitiator;
|
|
private byte[] _tersedateid;
|
|
public byte[] TerseDateID
|
|
{
|
|
get { return _tersedateid; }
|
|
set
|
|
{
|
|
if (value == null) { _tersedateid = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _tersedateid = new byte[value.Length]; Buffer.BlockCopy(value, 0, _tersedateid, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _startdatetime;
|
|
public byte[] StartDateTime
|
|
{
|
|
get { return _startdatetime; }
|
|
set
|
|
{
|
|
if (value == null) { _startdatetime = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _startdatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdatetime, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _enddatetime;
|
|
public byte[] EndDateTime
|
|
{
|
|
get { return _enddatetime; }
|
|
set
|
|
{
|
|
if (value == null) { _enddatetime = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _enddatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _enddatetime, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool AlreadyVoted;
|
|
private byte[] _votecast;
|
|
public byte[] VoteCast
|
|
{
|
|
get { return _votecast; }
|
|
set
|
|
{
|
|
if (value == null) { _votecast = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _votecast = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votecast, 0, value.Length); }
|
|
}
|
|
}
|
|
public float Majority;
|
|
public int Quorum;
|
|
private byte[] _proposaltext;
|
|
public byte[] ProposalText
|
|
{
|
|
get { return _proposaltext; }
|
|
set
|
|
{
|
|
if (value == null) { _proposaltext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _proposaltext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _proposaltext, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 41;
|
|
if (TerseDateID != null) { length += 1 + TerseDateID.Length; }
|
|
if (StartDateTime != null) { length += 1 + StartDateTime.Length; }
|
|
if (EndDateTime != null) { length += 1 + EndDateTime.Length; }
|
|
if (VoteCast != null) { length += 1 + VoteCast.Length; }
|
|
if (ProposalText != null) { length += 1 + ProposalText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ProposalDataBlock() { }
|
|
public ProposalDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
VoteID.FromBytes(bytes, i); i += 16;
|
|
VoteInitiator.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_tersedateid = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _tersedateid, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_startdatetime = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _startdatetime, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_enddatetime = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _enddatetime, 0, length); i += length;
|
|
AlreadyVoted = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_votecast = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _votecast, 0, length); i += length;
|
|
Majority = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Quorum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_proposaltext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _proposaltext, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(VoteID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(VoteInitiator.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(TerseDateID == null) { Console.WriteLine("Warning: TerseDateID is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TerseDateID.Length;
|
|
Buffer.BlockCopy(TerseDateID, 0, bytes, i, TerseDateID.Length); i += TerseDateID.Length;
|
|
if(StartDateTime == null) { Console.WriteLine("Warning: StartDateTime is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)StartDateTime.Length;
|
|
Buffer.BlockCopy(StartDateTime, 0, bytes, i, StartDateTime.Length); i += StartDateTime.Length;
|
|
if(EndDateTime == null) { Console.WriteLine("Warning: EndDateTime is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)EndDateTime.Length;
|
|
Buffer.BlockCopy(EndDateTime, 0, bytes, i, EndDateTime.Length); i += EndDateTime.Length;
|
|
bytes[i++] = (byte)((AlreadyVoted) ? 1 : 0);
|
|
if(VoteCast == null) { Console.WriteLine("Warning: VoteCast is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)VoteCast.Length;
|
|
Buffer.BlockCopy(VoteCast, 0, bytes, i, VoteCast.Length); i += VoteCast.Length;
|
|
Utils.FloatToBytes(Majority, bytes, i); i += 4;
|
|
Utils.IntToBytes(Quorum, bytes, i); i += 4;
|
|
if(ProposalText == null) { Console.WriteLine("Warning: ProposalText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ProposalText.Length;
|
|
Buffer.BlockCopy(ProposalText, 0, bytes, i, ProposalText.Length); i += ProposalText.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ProposalData --");
|
|
output.AppendLine(String.Format("VoteID: {0}", VoteID));
|
|
output.AppendLine(String.Format("VoteInitiator: {0}", VoteInitiator));
|
|
Helpers.FieldToString(output, TerseDateID, "TerseDateID");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, StartDateTime, "StartDateTime");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, EndDateTime, "EndDateTime");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("AlreadyVoted: {0}", AlreadyVoted));
|
|
Helpers.FieldToString(output, VoteCast, "VoteCast");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Majority: {0}", Majority));
|
|
output.AppendLine(String.Format("Quorum: {0}", Quorum));
|
|
Helpers.FieldToString(output, ProposalText, "ProposalText");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupActiveProposalItemReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionDataBlock TransactionData;
|
|
public ProposalDataBlock[] ProposalData;
|
|
|
|
public GroupActiveProposalItemReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 360;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionData = new TransactionDataBlock();
|
|
ProposalData = new ProposalDataBlock[0];
|
|
}
|
|
|
|
public GroupActiveProposalItemReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ProposalData.Length < count) {
|
|
ProposalData = new ProposalDataBlock[count];
|
|
for(int j = 0; j < count; j++) ProposalData[j] = new ProposalDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ProposalData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupActiveProposalItemReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ProposalData.Length < count) {
|
|
ProposalData = new ProposalDataBlock[count];
|
|
for(int j = 0; j < count; j++) ProposalData[j] = new ProposalDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ProposalData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ProposalData.Length; j++) { length += ProposalData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ProposalData.Length;
|
|
for (int j = 0; j < ProposalData.Length; j++) { ProposalData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupActiveProposalItemReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ProposalData.Length; j++)
|
|
{
|
|
output += ProposalData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupVoteHistoryRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.Append(String.Format("TransactionID: {0}", TransactionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupVoteHistoryRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public TransactionDataBlock TransactionData;
|
|
|
|
public GroupVoteHistoryRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 361;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
TransactionData = new TransactionDataBlock();
|
|
}
|
|
|
|
public GroupVoteHistoryRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupVoteHistoryRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length; length += TransactionData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupVoteHistoryRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupVoteHistoryItemReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransactionDataBlock : PacketBlock
|
|
{
|
|
public UUID TransactionID;
|
|
public uint TotalNumItems;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public TransactionDataBlock() { }
|
|
public TransactionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TransactionID.FromBytes(bytes, i); i += 16;
|
|
TotalNumItems = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransactionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(TotalNumItems, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransactionData --");
|
|
output.AppendLine(String.Format("TransactionID: {0}", TransactionID));
|
|
output.Append(String.Format("TotalNumItems: {0}", TotalNumItems));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HistoryItemDataBlock : PacketBlock
|
|
{
|
|
public UUID VoteID;
|
|
private byte[] _tersedateid;
|
|
public byte[] TerseDateID
|
|
{
|
|
get { return _tersedateid; }
|
|
set
|
|
{
|
|
if (value == null) { _tersedateid = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _tersedateid = new byte[value.Length]; Buffer.BlockCopy(value, 0, _tersedateid, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _startdatetime;
|
|
public byte[] StartDateTime
|
|
{
|
|
get { return _startdatetime; }
|
|
set
|
|
{
|
|
if (value == null) { _startdatetime = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _startdatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _startdatetime, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _enddatetime;
|
|
public byte[] EndDateTime
|
|
{
|
|
get { return _enddatetime; }
|
|
set
|
|
{
|
|
if (value == null) { _enddatetime = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _enddatetime = new byte[value.Length]; Buffer.BlockCopy(value, 0, _enddatetime, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID VoteInitiator;
|
|
private byte[] _votetype;
|
|
public byte[] VoteType
|
|
{
|
|
get { return _votetype; }
|
|
set
|
|
{
|
|
if (value == null) { _votetype = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _votetype = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votetype, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _voteresult;
|
|
public byte[] VoteResult
|
|
{
|
|
get { return _voteresult; }
|
|
set
|
|
{
|
|
if (value == null) { _voteresult = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _voteresult = new byte[value.Length]; Buffer.BlockCopy(value, 0, _voteresult, 0, value.Length); }
|
|
}
|
|
}
|
|
public float Majority;
|
|
public int Quorum;
|
|
private byte[] _proposaltext;
|
|
public byte[] ProposalText
|
|
{
|
|
get { return _proposaltext; }
|
|
set
|
|
{
|
|
if (value == null) { _proposaltext = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _proposaltext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _proposaltext, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 40;
|
|
if (TerseDateID != null) { length += 1 + TerseDateID.Length; }
|
|
if (StartDateTime != null) { length += 1 + StartDateTime.Length; }
|
|
if (EndDateTime != null) { length += 1 + EndDateTime.Length; }
|
|
if (VoteType != null) { length += 1 + VoteType.Length; }
|
|
if (VoteResult != null) { length += 1 + VoteResult.Length; }
|
|
if (ProposalText != null) { length += 2 + ProposalText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public HistoryItemDataBlock() { }
|
|
public HistoryItemDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
VoteID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_tersedateid = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _tersedateid, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_startdatetime = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _startdatetime, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_enddatetime = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _enddatetime, 0, length); i += length;
|
|
VoteInitiator.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_votetype = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _votetype, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_voteresult = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _voteresult, 0, length); i += length;
|
|
Majority = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Quorum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_proposaltext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _proposaltext, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(VoteID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(TerseDateID == null) { Console.WriteLine("Warning: TerseDateID is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TerseDateID.Length;
|
|
Buffer.BlockCopy(TerseDateID, 0, bytes, i, TerseDateID.Length); i += TerseDateID.Length;
|
|
if(StartDateTime == null) { Console.WriteLine("Warning: StartDateTime is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)StartDateTime.Length;
|
|
Buffer.BlockCopy(StartDateTime, 0, bytes, i, StartDateTime.Length); i += StartDateTime.Length;
|
|
if(EndDateTime == null) { Console.WriteLine("Warning: EndDateTime is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)EndDateTime.Length;
|
|
Buffer.BlockCopy(EndDateTime, 0, bytes, i, EndDateTime.Length); i += EndDateTime.Length;
|
|
Buffer.BlockCopy(VoteInitiator.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(VoteType == null) { Console.WriteLine("Warning: VoteType is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)VoteType.Length;
|
|
Buffer.BlockCopy(VoteType, 0, bytes, i, VoteType.Length); i += VoteType.Length;
|
|
if(VoteResult == null) { Console.WriteLine("Warning: VoteResult is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)VoteResult.Length;
|
|
Buffer.BlockCopy(VoteResult, 0, bytes, i, VoteResult.Length); i += VoteResult.Length;
|
|
Utils.FloatToBytes(Majority, bytes, i); i += 4;
|
|
Utils.IntToBytes(Quorum, bytes, i); i += 4;
|
|
if(ProposalText == null) { Console.WriteLine("Warning: ProposalText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(ProposalText.Length % 256);
|
|
bytes[i++] = (byte)((ProposalText.Length >> 8) % 256);
|
|
Buffer.BlockCopy(ProposalText, 0, bytes, i, ProposalText.Length); i += ProposalText.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HistoryItemData --");
|
|
output.AppendLine(String.Format("VoteID: {0}", VoteID));
|
|
Helpers.FieldToString(output, TerseDateID, "TerseDateID");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, StartDateTime, "StartDateTime");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, EndDateTime, "EndDateTime");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("VoteInitiator: {0}", VoteInitiator));
|
|
Helpers.FieldToString(output, VoteType, "VoteType");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, VoteResult, "VoteResult");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Majority: {0}", Majority));
|
|
output.AppendLine(String.Format("Quorum: {0}", Quorum));
|
|
Helpers.FieldToString(output, ProposalText, "ProposalText");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class VoteItemBlock : PacketBlock
|
|
{
|
|
public UUID CandidateID;
|
|
private byte[] _votecast;
|
|
public byte[] VoteCast
|
|
{
|
|
get { return _votecast; }
|
|
set
|
|
{
|
|
if (value == null) { _votecast = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _votecast = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votecast, 0, value.Length); }
|
|
}
|
|
}
|
|
public int NumVotes;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 20;
|
|
if (VoteCast != null) { length += 1 + VoteCast.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public VoteItemBlock() { }
|
|
public VoteItemBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
CandidateID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_votecast = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _votecast, 0, length); i += length;
|
|
NumVotes = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(CandidateID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(VoteCast == null) { Console.WriteLine("Warning: VoteCast is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)VoteCast.Length;
|
|
Buffer.BlockCopy(VoteCast, 0, bytes, i, VoteCast.Length); i += VoteCast.Length;
|
|
Utils.IntToBytes(NumVotes, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- VoteItem --");
|
|
output.AppendLine(String.Format("CandidateID: {0}", CandidateID));
|
|
Helpers.FieldToString(output, VoteCast, "VoteCast");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("NumVotes: {0}", NumVotes));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupVoteHistoryItemReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public TransactionDataBlock TransactionData;
|
|
public HistoryItemDataBlock HistoryItemData;
|
|
public VoteItemBlock[] VoteItem;
|
|
|
|
public GroupVoteHistoryItemReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 362;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
TransactionData = new TransactionDataBlock();
|
|
HistoryItemData = new HistoryItemDataBlock();
|
|
VoteItem = new VoteItemBlock[0];
|
|
}
|
|
|
|
public GroupVoteHistoryItemReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
HistoryItemData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(VoteItem.Length < count) {
|
|
VoteItem = new VoteItemBlock[count];
|
|
for(int j = 0; j < count; j++) VoteItem[j] = new VoteItemBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VoteItem[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupVoteHistoryItemReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TransactionData.FromBytes(bytes, ref i);
|
|
HistoryItemData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(VoteItem.Length < count) {
|
|
VoteItem = new VoteItemBlock[count];
|
|
for(int j = 0; j < count; j++) VoteItem[j] = new VoteItemBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VoteItem[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += TransactionData.Length; length += HistoryItemData.Length;;
|
|
length++;
|
|
for (int j = 0; j < VoteItem.Length; j++) { length += VoteItem[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TransactionData.ToBytes(bytes, ref i);
|
|
HistoryItemData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)VoteItem.Length;
|
|
for (int j = 0; j < VoteItem.Length; j++) { VoteItem[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupVoteHistoryItemReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TransactionData.ToString() + Environment.NewLine;
|
|
output += HistoryItemData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < VoteItem.Length; j++)
|
|
{
|
|
output += VoteItem[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class StartGroupProposalPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ProposalDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public int Quorum;
|
|
public float Majority;
|
|
public int Duration;
|
|
private byte[] _proposaltext;
|
|
public byte[] ProposalText
|
|
{
|
|
get { return _proposaltext; }
|
|
set
|
|
{
|
|
if (value == null) { _proposaltext = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _proposaltext = new byte[value.Length]; Buffer.BlockCopy(value, 0, _proposaltext, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (ProposalText != null) { length += 1 + ProposalText.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ProposalDataBlock() { }
|
|
public ProposalDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Quorum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Majority = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Duration = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_proposaltext = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _proposaltext, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Quorum, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Majority, bytes, i); i += 4;
|
|
Utils.IntToBytes(Duration, bytes, i); i += 4;
|
|
if(ProposalText == null) { Console.WriteLine("Warning: ProposalText is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ProposalText.Length;
|
|
Buffer.BlockCopy(ProposalText, 0, bytes, i, ProposalText.Length); i += ProposalText.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ProposalData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("Quorum: {0}", Quorum));
|
|
output.AppendLine(String.Format("Majority: {0}", Majority));
|
|
output.AppendLine(String.Format("Duration: {0}", Duration));
|
|
Helpers.FieldToString(output, ProposalText, "ProposalText");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.StartGroupProposal; } }
|
|
public AgentDataBlock AgentData;
|
|
public ProposalDataBlock ProposalData;
|
|
|
|
public StartGroupProposalPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 363;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ProposalData = new ProposalDataBlock();
|
|
}
|
|
|
|
public StartGroupProposalPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ProposalData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public StartGroupProposalPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ProposalData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ProposalData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ProposalData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- StartGroupProposal ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ProposalData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupProposalBallotPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ProposalDataBlock : PacketBlock
|
|
{
|
|
public UUID ProposalID;
|
|
public UUID GroupID;
|
|
private byte[] _votecast;
|
|
public byte[] VoteCast
|
|
{
|
|
get { return _votecast; }
|
|
set
|
|
{
|
|
if (value == null) { _votecast = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _votecast = new byte[value.Length]; Buffer.BlockCopy(value, 0, _votecast, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 32;
|
|
if (VoteCast != null) { length += 1 + VoteCast.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ProposalDataBlock() { }
|
|
public ProposalDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ProposalID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_votecast = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _votecast, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ProposalID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(VoteCast == null) { Console.WriteLine("Warning: VoteCast is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)VoteCast.Length;
|
|
Buffer.BlockCopy(VoteCast, 0, bytes, i, VoteCast.Length); i += VoteCast.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ProposalData --");
|
|
output.AppendLine(String.Format("ProposalID: {0}", ProposalID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
Helpers.FieldToString(output, VoteCast, "VoteCast");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupProposalBallot; } }
|
|
public AgentDataBlock AgentData;
|
|
public ProposalDataBlock ProposalData;
|
|
|
|
public GroupProposalBallotPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 364;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ProposalData = new ProposalDataBlock();
|
|
}
|
|
|
|
public GroupProposalBallotPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ProposalData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupProposalBallotPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ProposalData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ProposalData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ProposalData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupProposalBallot ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ProposalData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupMembersRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("RequestID: {0}", RequestID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupMembersRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public GroupMembersRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 366;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public GroupMembersRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupMembersRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupMembersRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupMembersReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
public int MemberCount;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
MemberCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(MemberCount, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.Append(String.Format("MemberCount: {0}", MemberCount));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MemberDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public int Contribution;
|
|
private byte[] _onlinestatus;
|
|
public byte[] OnlineStatus
|
|
{
|
|
get { return _onlinestatus; }
|
|
set
|
|
{
|
|
if (value == null) { _onlinestatus = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _onlinestatus = new byte[value.Length]; Buffer.BlockCopy(value, 0, _onlinestatus, 0, value.Length); }
|
|
}
|
|
}
|
|
public ulong AgentPowers;
|
|
private byte[] _title;
|
|
public byte[] Title
|
|
{
|
|
get { return _title; }
|
|
set
|
|
{
|
|
if (value == null) { _title = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool IsOwner;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 29;
|
|
if (OnlineStatus != null) { length += 1 + OnlineStatus.Length; }
|
|
if (Title != null) { length += 1 + Title.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MemberDataBlock() { }
|
|
public MemberDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
Contribution = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_onlinestatus = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _onlinestatus, 0, length); i += length;
|
|
AgentPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
length = (ushort)bytes[i++];
|
|
_title = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
|
|
IsOwner = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Contribution, bytes, i); i += 4;
|
|
if(OnlineStatus == null) { Console.WriteLine("Warning: OnlineStatus is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)OnlineStatus.Length;
|
|
Buffer.BlockCopy(OnlineStatus, 0, bytes, i, OnlineStatus.Length); i += OnlineStatus.Length;
|
|
Utils.UInt64ToBytes(AgentPowers, bytes, i); i += 8;
|
|
if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Title.Length;
|
|
Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
|
|
bytes[i++] = (byte)((IsOwner) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MemberData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("Contribution: {0}", Contribution));
|
|
Helpers.FieldToString(output, OnlineStatus, "OnlineStatus");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("AgentPowers: {0}", AgentPowers));
|
|
Helpers.FieldToString(output, Title, "Title");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("IsOwner: {0}", IsOwner));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupMembersReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public MemberDataBlock[] MemberData;
|
|
|
|
public GroupMembersReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 367;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
MemberData = new MemberDataBlock[0];
|
|
}
|
|
|
|
public GroupMembersReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(MemberData.Length < count) {
|
|
MemberData = new MemberDataBlock[count];
|
|
for(int j = 0; j < count; j++) MemberData[j] = new MemberDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MemberData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupMembersReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(MemberData.Length < count) {
|
|
MemberData = new MemberDataBlock[count];
|
|
for(int j = 0; j < count; j++) MemberData[j] = new MemberDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MemberData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
length++;
|
|
for (int j = 0; j < MemberData.Length; j++) { length += MemberData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)MemberData.Length;
|
|
for (int j = 0; j < MemberData.Length; j++) { MemberData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupMembersReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < MemberData.Length; j++)
|
|
{
|
|
output += MemberData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ActivateGroupPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ActivateGroup; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ActivateGroupPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 368;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ActivateGroupPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ActivateGroupPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ActivateGroup ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SetGroupContributionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public int Contribution;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
Contribution = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Contribution, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("Contribution: {0}", Contribution));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SetGroupContribution; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public SetGroupContributionPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 369;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public SetGroupContributionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SetGroupContributionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SetGroupContribution ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SetGroupAcceptNoticesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public bool AcceptNotices;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("AcceptNotices: {0}", AcceptNotices));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NewDataBlock : PacketBlock
|
|
{
|
|
public bool ListInProfile;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public NewDataBlock() { }
|
|
public NewDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ListInProfile = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((ListInProfile) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NewData --");
|
|
output.Append(String.Format("ListInProfile: {0}", ListInProfile));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SetGroupAcceptNotices; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
public NewDataBlock NewData;
|
|
|
|
public SetGroupAcceptNoticesPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 370;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
NewData = new NewDataBlock();
|
|
}
|
|
|
|
public SetGroupAcceptNoticesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
NewData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SetGroupAcceptNoticesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
NewData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length; length += NewData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
NewData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SetGroupAcceptNotices ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
output += NewData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupRoleDataRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("RequestID: {0}", RequestID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupRoleDataRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public GroupRoleDataRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 371;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public GroupRoleDataRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupRoleDataRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupRoleDataRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupRoleDataReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
public int RoleCount;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
RoleCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(RoleCount, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.Append(String.Format("RoleCount: {0}", RoleCount));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RoleDataBlock : PacketBlock
|
|
{
|
|
public UUID RoleID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _title;
|
|
public byte[] Title
|
|
{
|
|
get { return _title; }
|
|
set
|
|
{
|
|
if (value == null) { _title = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
public ulong Powers;
|
|
public uint Members;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Title != null) { length += 1 + Title.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RoleDataBlock() { }
|
|
public RoleDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RoleID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_title = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
Powers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Members = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Title.Length;
|
|
Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
Utils.UInt64ToBytes(Powers, bytes, i); i += 8;
|
|
Utils.UIntToBytes(Members, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RoleData --");
|
|
output.AppendLine(String.Format("RoleID: {0}", RoleID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Title, "Title");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Powers: {0}", Powers));
|
|
output.Append(String.Format("Members: {0}", Members));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupRoleDataReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
public RoleDataBlock[] RoleData;
|
|
|
|
public GroupRoleDataReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 372;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
RoleData = new RoleDataBlock[0];
|
|
}
|
|
|
|
public GroupRoleDataReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RoleData.Length < count) {
|
|
RoleData = new RoleDataBlock[count];
|
|
for(int j = 0; j < count; j++) RoleData[j] = new RoleDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RoleData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupRoleDataReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RoleData.Length < count) {
|
|
RoleData = new RoleDataBlock[count];
|
|
for(int j = 0; j < count; j++) RoleData[j] = new RoleDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RoleData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
length++;
|
|
for (int j = 0; j < RoleData.Length; j++) { length += RoleData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)RoleData.Length;
|
|
for (int j = 0; j < RoleData.Length; j++) { RoleData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupRoleDataReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < RoleData.Length; j++)
|
|
{
|
|
output += RoleData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupRoleMembersRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("RequestID: {0}", RequestID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupRoleMembersRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock GroupData;
|
|
|
|
public GroupRoleMembersRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 373;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock();
|
|
}
|
|
|
|
public GroupRoleMembersRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupRoleMembersRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
GroupData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += GroupData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
GroupData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupRoleMembersRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += GroupData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupRoleMembersReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
public uint TotalPairs;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 52;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
TotalPairs = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(TotalPairs, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.Append(String.Format("TotalPairs: {0}", TotalPairs));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MemberDataBlock : PacketBlock
|
|
{
|
|
public UUID RoleID;
|
|
public UUID MemberID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public MemberDataBlock() { }
|
|
public MemberDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RoleID.FromBytes(bytes, i); i += 16;
|
|
MemberID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(MemberID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MemberData --");
|
|
output.AppendLine(String.Format("RoleID: {0}", RoleID));
|
|
output.Append(String.Format("MemberID: {0}", MemberID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupRoleMembersReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public MemberDataBlock[] MemberData;
|
|
|
|
public GroupRoleMembersReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 374;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
MemberData = new MemberDataBlock[0];
|
|
}
|
|
|
|
public GroupRoleMembersReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(MemberData.Length < count) {
|
|
MemberData = new MemberDataBlock[count];
|
|
for(int j = 0; j < count; j++) MemberData[j] = new MemberDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MemberData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupRoleMembersReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(MemberData.Length < count) {
|
|
MemberData = new MemberDataBlock[count];
|
|
for(int j = 0; j < count; j++) MemberData[j] = new MemberDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ MemberData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < MemberData.Length; j++) { length += MemberData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)MemberData.Length;
|
|
for (int j = 0; j < MemberData.Length; j++) { MemberData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupRoleMembersReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < MemberData.Length; j++)
|
|
{
|
|
output += MemberData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupTitlesRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("RequestID: {0}", RequestID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupTitlesRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public GroupTitlesRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 375;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public GroupTitlesRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupTitlesRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupTitlesRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupTitlesReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
public UUID RequestID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("RequestID: {0}", RequestID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
private byte[] _title;
|
|
public byte[] Title
|
|
{
|
|
get { return _title; }
|
|
set
|
|
{
|
|
if (value == null) { _title = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID RoleID;
|
|
public bool Selected;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 17;
|
|
if (Title != null) { length += 1 + Title.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_title = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
|
|
RoleID.FromBytes(bytes, i); i += 16;
|
|
Selected = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Title.Length;
|
|
Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
|
|
Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((Selected) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
Helpers.FieldToString(output, Title, "Title");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("RoleID: {0}", RoleID));
|
|
output.Append(String.Format("Selected: {0}", Selected));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupTitlesReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock[] GroupData;
|
|
|
|
public GroupTitlesReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 376;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock[0];
|
|
}
|
|
|
|
public GroupTitlesReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupTitlesReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)GroupData.Length;
|
|
for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupTitlesReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < GroupData.Length; j++)
|
|
{
|
|
output += GroupData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupTitleUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
public UUID TitleRoleID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 64;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
TitleRoleID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(TitleRoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.Append(String.Format("TitleRoleID: {0}", TitleRoleID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupTitleUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public GroupTitleUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 377;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public GroupTitleUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public GroupTitleUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupTitleUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupRoleUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RoleDataBlock : PacketBlock
|
|
{
|
|
public UUID RoleID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _title;
|
|
public byte[] Title
|
|
{
|
|
get { return _title; }
|
|
set
|
|
{
|
|
if (value == null) { _title = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _title = new byte[value.Length]; Buffer.BlockCopy(value, 0, _title, 0, value.Length); }
|
|
}
|
|
}
|
|
public ulong Powers;
|
|
public byte UpdateType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 25;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
if (Title != null) { length += 1 + Title.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RoleDataBlock() { }
|
|
public RoleDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RoleID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_title = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _title, 0, length); i += length;
|
|
Powers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
UpdateType = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RoleID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
if(Title == null) { Console.WriteLine("Warning: Title is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Title.Length;
|
|
Buffer.BlockCopy(Title, 0, bytes, i, Title.Length); i += Title.Length;
|
|
Utils.UInt64ToBytes(Powers, bytes, i); i += 8;
|
|
bytes[i++] = UpdateType;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RoleData --");
|
|
output.AppendLine(String.Format("RoleID: {0}", RoleID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Title, "Title");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Powers: {0}", Powers));
|
|
output.Append(String.Format("UpdateType: {0}", UpdateType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupRoleUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public RoleDataBlock[] RoleData;
|
|
|
|
public GroupRoleUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 378;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RoleData = new RoleDataBlock[0];
|
|
}
|
|
|
|
public GroupRoleUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RoleData.Length < count) {
|
|
RoleData = new RoleDataBlock[count];
|
|
for(int j = 0; j < count; j++) RoleData[j] = new RoleDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RoleData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupRoleUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RoleData.Length < count) {
|
|
RoleData = new RoleDataBlock[count];
|
|
for(int j = 0; j < count; j++) RoleData[j] = new RoleDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RoleData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < RoleData.Length; j++) { length += RoleData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)RoleData.Length;
|
|
for (int j = 0; j < RoleData.Length; j++) { RoleData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupRoleUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < RoleData.Length; j++)
|
|
{
|
|
output += RoleData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LiveHelpGroupRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RequestDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public RequestDataBlock() { }
|
|
public RequestDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LiveHelpGroupRequest; } }
|
|
public RequestDataBlock RequestData;
|
|
|
|
public LiveHelpGroupRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 379;
|
|
Header.Reliable = true;
|
|
RequestData = new RequestDataBlock();
|
|
}
|
|
|
|
public LiveHelpGroupRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RequestData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LiveHelpGroupRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RequestData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += RequestData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RequestData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LiveHelpGroupRequest ---" + Environment.NewLine;
|
|
output += RequestData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LiveHelpGroupReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ReplyDataBlock : PacketBlock
|
|
{
|
|
public UUID RequestID;
|
|
public UUID GroupID;
|
|
private byte[] _selection;
|
|
public byte[] Selection
|
|
{
|
|
get { return _selection; }
|
|
set
|
|
{
|
|
if (value == null) { _selection = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _selection = new byte[value.Length]; Buffer.BlockCopy(value, 0, _selection, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 32;
|
|
if (Selection != null) { length += 1 + Selection.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ReplyDataBlock() { }
|
|
public ReplyDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RequestID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_selection = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _selection, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(RequestID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Selection == null) { Console.WriteLine("Warning: Selection is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Selection.Length;
|
|
Buffer.BlockCopy(Selection, 0, bytes, i, Selection.Length); i += Selection.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ReplyData --");
|
|
output.AppendLine(String.Format("RequestID: {0}", RequestID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
Helpers.FieldToString(output, Selection, "Selection");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LiveHelpGroupReply; } }
|
|
public ReplyDataBlock ReplyData;
|
|
|
|
public LiveHelpGroupReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 380;
|
|
Header.Reliable = true;
|
|
ReplyData = new ReplyDataBlock();
|
|
}
|
|
|
|
public LiveHelpGroupReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ReplyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LiveHelpGroupReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ReplyData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ReplyData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ReplyData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LiveHelpGroupReply ---" + Environment.NewLine;
|
|
output += ReplyData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentWearablesRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentWearablesRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentWearablesRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 381;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentWearablesRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentWearablesRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentWearablesRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentWearablesUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint SerialNum;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
SerialNum = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(SerialNum, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("SerialNum: {0}", SerialNum));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class WearableDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID AssetID;
|
|
public byte WearableType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 33;
|
|
}
|
|
}
|
|
|
|
public WearableDataBlock() { }
|
|
public WearableDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
WearableType = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = WearableType;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- WearableData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.Append(String.Format("WearableType: {0}", WearableType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentWearablesUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public WearableDataBlock[] WearableData;
|
|
|
|
public AgentWearablesUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 382;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
WearableData = new WearableDataBlock[0];
|
|
}
|
|
|
|
public AgentWearablesUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentWearablesUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)WearableData.Length;
|
|
for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentWearablesUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < WearableData.Length; j++)
|
|
{
|
|
output += WearableData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentIsNowWearingPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class WearableDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public byte WearableType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public WearableDataBlock() { }
|
|
public WearableDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
WearableType = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = WearableType;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- WearableData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.Append(String.Format("WearableType: {0}", WearableType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentIsNowWearing; } }
|
|
public AgentDataBlock AgentData;
|
|
public WearableDataBlock[] WearableData;
|
|
|
|
public AgentIsNowWearingPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 383;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
WearableData = new WearableDataBlock[0];
|
|
}
|
|
|
|
public AgentIsNowWearingPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentIsNowWearingPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)WearableData.Length;
|
|
for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentIsNowWearing ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < WearableData.Length; j++)
|
|
{
|
|
output += WearableData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentCachedTexturePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public int SerialNum;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
SerialNum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(SerialNum, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("SerialNum: {0}", SerialNum));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class WearableDataBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public byte TextureIndex;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public WearableDataBlock() { }
|
|
public WearableDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
TextureIndex = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = TextureIndex;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- WearableData --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.Append(String.Format("TextureIndex: {0}", TextureIndex));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentCachedTexture; } }
|
|
public AgentDataBlock AgentData;
|
|
public WearableDataBlock[] WearableData;
|
|
|
|
public AgentCachedTexturePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 384;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
WearableData = new WearableDataBlock[0];
|
|
}
|
|
|
|
public AgentCachedTexturePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentCachedTexturePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)WearableData.Length;
|
|
for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentCachedTexture ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < WearableData.Length; j++)
|
|
{
|
|
output += WearableData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentCachedTextureResponsePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public int SerialNum;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 36;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
SerialNum = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(SerialNum, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("SerialNum: {0}", SerialNum));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class WearableDataBlock : PacketBlock
|
|
{
|
|
public UUID TextureID;
|
|
public byte TextureIndex;
|
|
private byte[] _hostname;
|
|
public byte[] HostName
|
|
{
|
|
get { return _hostname; }
|
|
set
|
|
{
|
|
if (value == null) { _hostname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _hostname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _hostname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 17;
|
|
if (HostName != null) { length += 1 + HostName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public WearableDataBlock() { }
|
|
public WearableDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TextureID.FromBytes(bytes, i); i += 16;
|
|
TextureIndex = (byte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_hostname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _hostname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TextureID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = TextureIndex;
|
|
if(HostName == null) { Console.WriteLine("Warning: HostName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)HostName.Length;
|
|
Buffer.BlockCopy(HostName, 0, bytes, i, HostName.Length); i += HostName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- WearableData --");
|
|
output.AppendLine(String.Format("TextureID: {0}", TextureID));
|
|
output.AppendLine(String.Format("TextureIndex: {0}", TextureIndex));
|
|
Helpers.FieldToString(output, HostName, "HostName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentCachedTextureResponse; } }
|
|
public AgentDataBlock AgentData;
|
|
public WearableDataBlock[] WearableData;
|
|
|
|
public AgentCachedTextureResponsePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 385;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
WearableData = new WearableDataBlock[0];
|
|
}
|
|
|
|
public AgentCachedTextureResponsePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentCachedTextureResponsePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(WearableData.Length < count) {
|
|
WearableData = new WearableDataBlock[count];
|
|
for(int j = 0; j < count; j++) WearableData[j] = new WearableDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ WearableData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)WearableData.Length;
|
|
for (int j = 0; j < WearableData.Length; j++) { WearableData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentCachedTextureResponse ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < WearableData.Length; j++)
|
|
{
|
|
output += WearableData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentDataUpdateRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentDataUpdateRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentDataUpdateRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 386;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentDataUpdateRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentDataUpdateRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentDataUpdateRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentDataUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
private byte[] _firstname;
|
|
public byte[] FirstName
|
|
{
|
|
get { return _firstname; }
|
|
set
|
|
{
|
|
if (value == null) { _firstname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _firstname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _firstname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _lastname;
|
|
public byte[] LastName
|
|
{
|
|
get { return _lastname; }
|
|
set
|
|
{
|
|
if (value == null) { _lastname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _lastname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _lastname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _grouptitle;
|
|
public byte[] GroupTitle
|
|
{
|
|
get { return _grouptitle; }
|
|
set
|
|
{
|
|
if (value == null) { _grouptitle = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _grouptitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _grouptitle, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID ActiveGroupID;
|
|
public ulong GroupPowers;
|
|
private byte[] _groupname;
|
|
public byte[] GroupName
|
|
{
|
|
get { return _groupname; }
|
|
set
|
|
{
|
|
if (value == null) { _groupname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 40;
|
|
if (FirstName != null) { length += 1 + FirstName.Length; }
|
|
if (LastName != null) { length += 1 + LastName.Length; }
|
|
if (GroupTitle != null) { length += 1 + GroupTitle.Length; }
|
|
if (GroupName != null) { length += 1 + GroupName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_firstname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _firstname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_lastname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _lastname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_grouptitle = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _grouptitle, 0, length); i += length;
|
|
ActiveGroupID.FromBytes(bytes, i); i += 16;
|
|
GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
length = (ushort)bytes[i++];
|
|
_groupname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(FirstName == null) { Console.WriteLine("Warning: FirstName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)FirstName.Length;
|
|
Buffer.BlockCopy(FirstName, 0, bytes, i, FirstName.Length); i += FirstName.Length;
|
|
if(LastName == null) { Console.WriteLine("Warning: LastName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)LastName.Length;
|
|
Buffer.BlockCopy(LastName, 0, bytes, i, LastName.Length); i += LastName.Length;
|
|
if(GroupTitle == null) { Console.WriteLine("Warning: GroupTitle is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupTitle.Length;
|
|
Buffer.BlockCopy(GroupTitle, 0, bytes, i, GroupTitle.Length); i += GroupTitle.Length;
|
|
Buffer.BlockCopy(ActiveGroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(GroupPowers, bytes, i); i += 8;
|
|
if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupName.Length;
|
|
Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
Helpers.FieldToString(output, FirstName, "FirstName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, LastName, "LastName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, GroupTitle, "GroupTitle");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ActiveGroupID: {0}", ActiveGroupID));
|
|
output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
|
|
Helpers.FieldToString(output, GroupName, "GroupName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentDataUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentDataUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 387;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentDataUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentDataUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentDataUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentGroupDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
public ulong AgentPowers;
|
|
private byte[] _grouptitle;
|
|
public byte[] GroupTitle
|
|
{
|
|
get { return _grouptitle; }
|
|
set
|
|
{
|
|
if (value == null) { _grouptitle = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _grouptitle = new byte[value.Length]; Buffer.BlockCopy(value, 0, _grouptitle, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 40;
|
|
if (GroupTitle != null) { length += 1 + GroupTitle.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AgentGroupDataBlock() { }
|
|
public AgentGroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
AgentPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
length = (ushort)bytes[i++];
|
|
_grouptitle = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _grouptitle, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(AgentPowers, bytes, i); i += 8;
|
|
if(GroupTitle == null) { Console.WriteLine("Warning: GroupTitle is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupTitle.Length;
|
|
Buffer.BlockCopy(GroupTitle, 0, bytes, i, GroupTitle.Length); i += GroupTitle.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentGroupData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("AgentPowers: {0}", AgentPowers));
|
|
Helpers.FieldToString(output, GroupTitle, "GroupTitle");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.GroupDataUpdate; } }
|
|
public AgentGroupDataBlock[] AgentGroupData;
|
|
|
|
public GroupDataUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 388;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentGroupData = new AgentGroupDataBlock[0];
|
|
}
|
|
|
|
public GroupDataUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(AgentGroupData.Length < count) {
|
|
AgentGroupData = new AgentGroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) AgentGroupData[j] = new AgentGroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentGroupData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public GroupDataUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(AgentGroupData.Length < count) {
|
|
AgentGroupData = new AgentGroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) AgentGroupData[j] = new AgentGroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentGroupData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < AgentGroupData.Length; j++) { length += AgentGroupData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)AgentGroupData.Length;
|
|
for (int j = 0; j < AgentGroupData.Length; j++) { AgentGroupData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- GroupDataUpdate ---" + Environment.NewLine;
|
|
for (int j = 0; j < AgentGroupData.Length; j++)
|
|
{
|
|
output += AgentGroupData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentGroupDataUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public ulong GroupPowers;
|
|
public bool AcceptNotices;
|
|
public UUID GroupInsigniaID;
|
|
public int Contribution;
|
|
private byte[] _groupname;
|
|
public byte[] GroupName
|
|
{
|
|
get { return _groupname; }
|
|
set
|
|
{
|
|
if (value == null) { _groupname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _groupname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _groupname, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 45;
|
|
if (GroupName != null) { length += 1 + GroupName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
GroupInsigniaID.FromBytes(bytes, i); i += 16;
|
|
Contribution = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_groupname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _groupname, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(GroupPowers, bytes, i); i += 8;
|
|
bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
|
|
Buffer.BlockCopy(GroupInsigniaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Contribution, bytes, i); i += 4;
|
|
if(GroupName == null) { Console.WriteLine("Warning: GroupName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)GroupName.Length;
|
|
Buffer.BlockCopy(GroupName, 0, bytes, i, GroupName.Length); i += GroupName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
|
|
output.AppendLine(String.Format("AcceptNotices: {0}", AcceptNotices));
|
|
output.AppendLine(String.Format("GroupInsigniaID: {0}", GroupInsigniaID));
|
|
output.AppendLine(String.Format("Contribution: {0}", Contribution));
|
|
Helpers.FieldToString(output, GroupName, "GroupName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentGroupDataUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock[] GroupData;
|
|
|
|
public AgentGroupDataUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 389;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock[0];
|
|
}
|
|
|
|
public AgentGroupDataUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentGroupDataUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)GroupData.Length;
|
|
for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentGroupDataUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < GroupData.Length; j++)
|
|
{
|
|
output += GroupData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentDropGroupPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentDropGroup; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentDropGroupPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 390;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentDropGroupPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentDropGroupPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentDropGroup ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateTrustedCircuitPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
public UUID EndPointID;
|
|
public byte[] Digest;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EndPointID.FromBytes(bytes, i); i += 16;
|
|
Digest = new byte[32];
|
|
Buffer.BlockCopy(bytes, i, Digest, 0, 32); i += 32;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(EndPointID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Digest, 0, bytes, i, 32);i += 32;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
output.AppendLine(String.Format("EndPointID: {0}", EndPointID));
|
|
Helpers.FieldToString(output, Digest, "Digest");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateTrustedCircuit; } }
|
|
public DataBlockBlock DataBlock;
|
|
|
|
public CreateTrustedCircuitPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 392;
|
|
Header.Reliable = true;
|
|
DataBlock = new DataBlockBlock();
|
|
}
|
|
|
|
public CreateTrustedCircuitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CreateTrustedCircuitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += DataBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateTrustedCircuit ---" + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DenyTrustedCircuitPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
public UUID EndPointID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
EndPointID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(EndPointID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
output.Append(String.Format("EndPointID: {0}", EndPointID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DenyTrustedCircuit; } }
|
|
public DataBlockBlock DataBlock;
|
|
|
|
public DenyTrustedCircuitPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 393;
|
|
Header.Reliable = true;
|
|
DataBlock = new DataBlockBlock();
|
|
}
|
|
|
|
public DenyTrustedCircuitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DenyTrustedCircuitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += DataBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DenyTrustedCircuit ---" + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestTrustedCircuitPacket : Packet
|
|
{
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestTrustedCircuit; } }
|
|
|
|
public RequestTrustedCircuitPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 394;
|
|
Header.Reliable = true;
|
|
}
|
|
|
|
public RequestTrustedCircuitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public RequestTrustedCircuitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestTrustedCircuit ---" + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezSingleAttachmentFromInvPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID OwnerID;
|
|
public byte AttachmentPt;
|
|
public uint ItemFlags;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 49;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
AttachmentPt = (byte)bytes[i++];
|
|
ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = AttachmentPt;
|
|
Utils.UIntToBytes(ItemFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("AttachmentPt: {0}", AttachmentPt));
|
|
output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RezSingleAttachmentFromInv; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public RezSingleAttachmentFromInvPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 395;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public RezSingleAttachmentFromInvPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RezSingleAttachmentFromInvPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RezSingleAttachmentFromInv ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RezMultipleAttachmentsFromInvPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HeaderDataBlock : PacketBlock
|
|
{
|
|
public UUID CompoundMsgID;
|
|
public byte TotalObjects;
|
|
public bool FirstDetachAll;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 18;
|
|
}
|
|
}
|
|
|
|
public HeaderDataBlock() { }
|
|
public HeaderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
CompoundMsgID.FromBytes(bytes, i); i += 16;
|
|
TotalObjects = (byte)bytes[i++];
|
|
FirstDetachAll = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(CompoundMsgID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = TotalObjects;
|
|
bytes[i++] = (byte)((FirstDetachAll) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HeaderData --");
|
|
output.AppendLine(String.Format("CompoundMsgID: {0}", CompoundMsgID));
|
|
output.AppendLine(String.Format("TotalObjects: {0}", TotalObjects));
|
|
output.Append(String.Format("FirstDetachAll: {0}", FirstDetachAll));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ItemID;
|
|
public UUID OwnerID;
|
|
public byte AttachmentPt;
|
|
public uint ItemFlags;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 49;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
AttachmentPt = (byte)bytes[i++];
|
|
ItemFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = AttachmentPt;
|
|
Utils.UIntToBytes(ItemFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("AttachmentPt: {0}", AttachmentPt));
|
|
output.AppendLine(String.Format("ItemFlags: {0}", ItemFlags));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RezMultipleAttachmentsFromInv; } }
|
|
public AgentDataBlock AgentData;
|
|
public HeaderDataBlock HeaderData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public RezMultipleAttachmentsFromInvPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 396;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
HeaderData = new HeaderDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public RezMultipleAttachmentsFromInvPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RezMultipleAttachmentsFromInvPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += HeaderData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
HeaderData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RezMultipleAttachmentsFromInv ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += HeaderData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DetachAttachmentIntoInvPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID ItemID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("ItemID: {0}", ItemID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.DetachAttachmentIntoInv; } }
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public DetachAttachmentIntoInvPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 397;
|
|
Header.Reliable = true;
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public DetachAttachmentIntoInvPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public DetachAttachmentIntoInvPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- DetachAttachmentIntoInv ---" + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CreateNewOutfitAttachmentsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class HeaderDataBlock : PacketBlock
|
|
{
|
|
public UUID NewFolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public HeaderDataBlock() { }
|
|
public HeaderDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
NewFolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(NewFolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- HeaderData --");
|
|
output.Append(String.Format("NewFolderID: {0}", NewFolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID OldItemID;
|
|
public UUID OldFolderID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
OldItemID.FromBytes(bytes, i); i += 16;
|
|
OldFolderID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(OldItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OldFolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("OldItemID: {0}", OldItemID));
|
|
output.Append(String.Format("OldFolderID: {0}", OldFolderID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CreateNewOutfitAttachments; } }
|
|
public AgentDataBlock AgentData;
|
|
public HeaderDataBlock HeaderData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public CreateNewOutfitAttachmentsPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 398;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
HeaderData = new HeaderDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public CreateNewOutfitAttachmentsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public CreateNewOutfitAttachmentsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
HeaderData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += HeaderData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
HeaderData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CreateNewOutfitAttachments ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += HeaderData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UserInfoRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UserInfoRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public UserInfoRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 399;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public UserInfoRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UserInfoRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UserInfoRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UserInfoReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UserDataBlock : PacketBlock
|
|
{
|
|
public bool IMViaEMail;
|
|
private byte[] _directoryvisibility;
|
|
public byte[] DirectoryVisibility
|
|
{
|
|
get { return _directoryvisibility; }
|
|
set
|
|
{
|
|
if (value == null) { _directoryvisibility = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _directoryvisibility = new byte[value.Length]; Buffer.BlockCopy(value, 0, _directoryvisibility, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _email;
|
|
public byte[] EMail
|
|
{
|
|
get { return _email; }
|
|
set
|
|
{
|
|
if (value == null) { _email = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _email = new byte[value.Length]; Buffer.BlockCopy(value, 0, _email, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 1;
|
|
if (DirectoryVisibility != null) { length += 1 + DirectoryVisibility.Length; }
|
|
if (EMail != null) { length += 2 + EMail.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public UserDataBlock() { }
|
|
public UserDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
IMViaEMail = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_directoryvisibility = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _directoryvisibility, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_email = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _email, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((IMViaEMail) ? 1 : 0);
|
|
if(DirectoryVisibility == null) { Console.WriteLine("Warning: DirectoryVisibility is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)DirectoryVisibility.Length;
|
|
Buffer.BlockCopy(DirectoryVisibility, 0, bytes, i, DirectoryVisibility.Length); i += DirectoryVisibility.Length;
|
|
if(EMail == null) { Console.WriteLine("Warning: EMail is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(EMail.Length % 256);
|
|
bytes[i++] = (byte)((EMail.Length >> 8) % 256);
|
|
Buffer.BlockCopy(EMail, 0, bytes, i, EMail.Length); i += EMail.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UserData --");
|
|
output.AppendLine(String.Format("IMViaEMail: {0}", IMViaEMail));
|
|
Helpers.FieldToString(output, DirectoryVisibility, "DirectoryVisibility");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, EMail, "EMail");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UserInfoReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public UserDataBlock UserData;
|
|
|
|
public UserInfoReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 400;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
UserData = new UserDataBlock();
|
|
}
|
|
|
|
public UserInfoReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UserData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UserInfoReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UserData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += UserData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
UserData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UserInfoReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += UserData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UpdateUserInfoPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class UserDataBlock : PacketBlock
|
|
{
|
|
public bool IMViaEMail;
|
|
private byte[] _directoryvisibility;
|
|
public byte[] DirectoryVisibility
|
|
{
|
|
get { return _directoryvisibility; }
|
|
set
|
|
{
|
|
if (value == null) { _directoryvisibility = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _directoryvisibility = new byte[value.Length]; Buffer.BlockCopy(value, 0, _directoryvisibility, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 1;
|
|
if (DirectoryVisibility != null) { length += 1 + DirectoryVisibility.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public UserDataBlock() { }
|
|
public UserDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
IMViaEMail = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
length = (ushort)bytes[i++];
|
|
_directoryvisibility = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _directoryvisibility, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((IMViaEMail) ? 1 : 0);
|
|
if(DirectoryVisibility == null) { Console.WriteLine("Warning: DirectoryVisibility is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)DirectoryVisibility.Length;
|
|
Buffer.BlockCopy(DirectoryVisibility, 0, bytes, i, DirectoryVisibility.Length); i += DirectoryVisibility.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- UserData --");
|
|
output.AppendLine(String.Format("IMViaEMail: {0}", IMViaEMail));
|
|
Helpers.FieldToString(output, DirectoryVisibility, "DirectoryVisibility");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.UpdateUserInfo; } }
|
|
public AgentDataBlock AgentData;
|
|
public UserDataBlock UserData;
|
|
|
|
public UpdateUserInfoPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 401;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
UserData = new UserDataBlock();
|
|
}
|
|
|
|
public UpdateUserInfoPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UserData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public UpdateUserInfoPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
UserData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += UserData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
UserData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- UpdateUserInfo ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += UserData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InitiateDownloadPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class FileDataBlock : PacketBlock
|
|
{
|
|
private byte[] _simfilename;
|
|
public byte[] SimFilename
|
|
{
|
|
get { return _simfilename; }
|
|
set
|
|
{
|
|
if (value == null) { _simfilename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _simfilename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _simfilename, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _viewerfilename;
|
|
public byte[] ViewerFilename
|
|
{
|
|
get { return _viewerfilename; }
|
|
set
|
|
{
|
|
if (value == null) { _viewerfilename = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _viewerfilename = new byte[value.Length]; Buffer.BlockCopy(value, 0, _viewerfilename, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (SimFilename != null) { length += 1 + SimFilename.Length; }
|
|
if (ViewerFilename != null) { length += 1 + ViewerFilename.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public FileDataBlock() { }
|
|
public FileDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_simfilename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _simfilename, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_viewerfilename = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _viewerfilename, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(SimFilename == null) { Console.WriteLine("Warning: SimFilename is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SimFilename.Length;
|
|
Buffer.BlockCopy(SimFilename, 0, bytes, i, SimFilename.Length); i += SimFilename.Length;
|
|
if(ViewerFilename == null) { Console.WriteLine("Warning: ViewerFilename is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ViewerFilename.Length;
|
|
Buffer.BlockCopy(ViewerFilename, 0, bytes, i, ViewerFilename.Length); i += ViewerFilename.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- FileData --");
|
|
Helpers.FieldToString(output, SimFilename, "SimFilename");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, ViewerFilename, "ViewerFilename");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.InitiateDownload; } }
|
|
public AgentDataBlock AgentData;
|
|
public FileDataBlock FileData;
|
|
|
|
public InitiateDownloadPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 403;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
FileData = new FileDataBlock();
|
|
}
|
|
|
|
public InitiateDownloadPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FileData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public InitiateDownloadPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
FileData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += FileData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
FileData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- InitiateDownload ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += FileData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SystemMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class MethodDataBlock : PacketBlock
|
|
{
|
|
private byte[] _method;
|
|
public byte[] Method
|
|
{
|
|
get { return _method; }
|
|
set
|
|
{
|
|
if (value == null) { _method = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _method = new byte[value.Length]; Buffer.BlockCopy(value, 0, _method, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID Invoice;
|
|
public byte[] Digest;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 48;
|
|
if (Method != null) { length += 1 + Method.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public MethodDataBlock() { }
|
|
public MethodDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_method = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _method, 0, length); i += length;
|
|
Invoice.FromBytes(bytes, i); i += 16;
|
|
Digest = new byte[32];
|
|
Buffer.BlockCopy(bytes, i, Digest, 0, 32); i += 32;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Method == null) { Console.WriteLine("Warning: Method is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Method.Length;
|
|
Buffer.BlockCopy(Method, 0, bytes, i, Method.Length); i += Method.Length;
|
|
Buffer.BlockCopy(Invoice.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Digest, 0, bytes, i, 32);i += 32;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- MethodData --");
|
|
Helpers.FieldToString(output, Method, "Method");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Invoice: {0}", Invoice));
|
|
Helpers.FieldToString(output, Digest, "Digest");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParamListBlock : PacketBlock
|
|
{
|
|
private byte[] _parameter;
|
|
public byte[] Parameter
|
|
{
|
|
get { return _parameter; }
|
|
set
|
|
{
|
|
if (value == null) { _parameter = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _parameter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _parameter, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Parameter != null) { length += 1 + Parameter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParamListBlock() { }
|
|
public ParamListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_parameter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _parameter, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Parameter == null) { Console.WriteLine("Warning: Parameter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Parameter.Length;
|
|
Buffer.BlockCopy(Parameter, 0, bytes, i, Parameter.Length); i += Parameter.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParamList --");
|
|
Helpers.FieldToString(output, Parameter, "Parameter");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SystemMessage; } }
|
|
public MethodDataBlock MethodData;
|
|
public ParamListBlock[] ParamList;
|
|
|
|
public SystemMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 404;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
MethodData = new MethodDataBlock();
|
|
ParamList = new ParamListBlock[0];
|
|
}
|
|
|
|
public SystemMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public SystemMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
MethodData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ParamList.Length < count) {
|
|
ParamList = new ParamListBlock[count];
|
|
for(int j = 0; j < count; j++) ParamList[j] = new ParamListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ParamList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += MethodData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
MethodData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ParamList.Length;
|
|
for (int j = 0; j < ParamList.Length; j++) { ParamList[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SystemMessage ---" + Environment.NewLine;
|
|
output += MethodData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ParamList.Length; j++)
|
|
{
|
|
output += ParamList[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapLayerRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
public uint EstateID;
|
|
public bool Godlike;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 41;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EstateID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Godlike) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("EstateID: {0}", EstateID));
|
|
output.Append(String.Format("Godlike: {0}", Godlike));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapLayerRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public MapLayerRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 405;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public MapLayerRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MapLayerRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapLayerRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapLayerReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LayerDataBlock : PacketBlock
|
|
{
|
|
public uint Left;
|
|
public uint Right;
|
|
public uint Top;
|
|
public uint Bottom;
|
|
public UUID ImageID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public LayerDataBlock() { }
|
|
public LayerDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Left = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Right = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Top = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Bottom = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ImageID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Left, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Right, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Top, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Bottom, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- LayerData --");
|
|
output.AppendLine(String.Format("Left: {0}", Left));
|
|
output.AppendLine(String.Format("Right: {0}", Right));
|
|
output.AppendLine(String.Format("Top: {0}", Top));
|
|
output.AppendLine(String.Format("Bottom: {0}", Bottom));
|
|
output.Append(String.Format("ImageID: {0}", ImageID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapLayerReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public LayerDataBlock[] LayerData;
|
|
|
|
public MapLayerReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 406;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
LayerData = new LayerDataBlock[0];
|
|
}
|
|
|
|
public MapLayerReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(LayerData.Length < count) {
|
|
LayerData = new LayerDataBlock[count];
|
|
for(int j = 0; j < count; j++) LayerData[j] = new LayerDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ LayerData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MapLayerReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(LayerData.Length < count) {
|
|
LayerData = new LayerDataBlock[count];
|
|
for(int j = 0; j < count; j++) LayerData[j] = new LayerDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ LayerData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < LayerData.Length; j++) { length += LayerData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)LayerData.Length;
|
|
for (int j = 0; j < LayerData.Length; j++) { LayerData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapLayerReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < LayerData.Length; j++)
|
|
{
|
|
output += LayerData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapBlockRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
public uint EstateID;
|
|
public bool Godlike;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 41;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EstateID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Godlike) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("EstateID: {0}", EstateID));
|
|
output.Append(String.Format("Godlike: {0}", Godlike));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PositionDataBlock : PacketBlock
|
|
{
|
|
public ushort MinX;
|
|
public ushort MaxX;
|
|
public ushort MinY;
|
|
public ushort MaxY;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 8;
|
|
}
|
|
}
|
|
|
|
public PositionDataBlock() { }
|
|
public PositionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
MinX = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
MaxX = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
MinY = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
MaxY = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)(MinX % 256);
|
|
bytes[i++] = (byte)((MinX >> 8) % 256);
|
|
bytes[i++] = (byte)(MaxX % 256);
|
|
bytes[i++] = (byte)((MaxX >> 8) % 256);
|
|
bytes[i++] = (byte)(MinY % 256);
|
|
bytes[i++] = (byte)((MinY >> 8) % 256);
|
|
bytes[i++] = (byte)(MaxY % 256);
|
|
bytes[i++] = (byte)((MaxY >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PositionData --");
|
|
output.AppendLine(String.Format("MinX: {0}", MinX));
|
|
output.AppendLine(String.Format("MaxX: {0}", MaxX));
|
|
output.AppendLine(String.Format("MinY: {0}", MinY));
|
|
output.Append(String.Format("MaxY: {0}", MaxY));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapBlockRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public PositionDataBlock PositionData;
|
|
|
|
public MapBlockRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 407;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
PositionData = new PositionDataBlock();
|
|
}
|
|
|
|
public MapBlockRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PositionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MapBlockRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
PositionData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += PositionData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
PositionData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapBlockRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += PositionData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapNameRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
public uint EstateID;
|
|
public bool Godlike;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 41;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EstateID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Godlike) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("EstateID: {0}", EstateID));
|
|
output.Append(String.Format("Godlike: {0}", Godlike));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NameDataBlock : PacketBlock
|
|
{
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public NameDataBlock() { }
|
|
public NameDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NameData --");
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapNameRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public NameDataBlock NameData;
|
|
|
|
public MapNameRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 408;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
NameData = new NameDataBlock();
|
|
}
|
|
|
|
public MapNameRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
NameData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MapNameRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
NameData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += NameData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
NameData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapNameRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += NameData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapBlockReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public ushort X;
|
|
public ushort Y;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte Access;
|
|
public uint RegionFlags;
|
|
public byte WaterHeight;
|
|
public byte Agents;
|
|
public UUID MapImageID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 27;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
X = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
Y = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
Access = (byte)bytes[i++];
|
|
RegionFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
WaterHeight = (byte)bytes[i++];
|
|
Agents = (byte)bytes[i++];
|
|
MapImageID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)(X % 256);
|
|
bytes[i++] = (byte)((X >> 8) % 256);
|
|
bytes[i++] = (byte)(Y % 256);
|
|
bytes[i++] = (byte)((Y >> 8) % 256);
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
bytes[i++] = Access;
|
|
Utils.UIntToBytes(RegionFlags, bytes, i); i += 4;
|
|
bytes[i++] = WaterHeight;
|
|
bytes[i++] = Agents;
|
|
Buffer.BlockCopy(MapImageID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("X: {0}", X));
|
|
output.AppendLine(String.Format("Y: {0}", Y));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Access: {0}", Access));
|
|
output.AppendLine(String.Format("RegionFlags: {0}", RegionFlags));
|
|
output.AppendLine(String.Format("WaterHeight: {0}", WaterHeight));
|
|
output.AppendLine(String.Format("Agents: {0}", Agents));
|
|
output.Append(String.Format("MapImageID: {0}", MapImageID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapBlockReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock[] Data;
|
|
|
|
public MapBlockReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 409;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public MapBlockReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MapBlockReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapBlockReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapItemRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public uint Flags;
|
|
public uint EstateID;
|
|
public bool Godlike;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 41;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EstateID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Godlike = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EstateID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Godlike) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("EstateID: {0}", EstateID));
|
|
output.Append(String.Format("Godlike: {0}", Godlike));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestDataBlock : PacketBlock
|
|
{
|
|
public uint ItemType;
|
|
public ulong RegionHandle;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public RequestDataBlock() { }
|
|
public RequestDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ItemType, bytes, i); i += 4;
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestData --");
|
|
output.AppendLine(String.Format("ItemType: {0}", ItemType));
|
|
output.Append(String.Format("RegionHandle: {0}", RegionHandle));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapItemRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public RequestDataBlock RequestData;
|
|
|
|
public MapItemRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 410;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RequestData = new RequestDataBlock();
|
|
}
|
|
|
|
public MapItemRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public MapItemRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RequestData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RequestData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapItemRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RequestData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MapItemReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public uint Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestDataBlock : PacketBlock
|
|
{
|
|
public uint ItemType;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public RequestDataBlock() { }
|
|
public RequestDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ItemType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ItemType, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestData --");
|
|
output.Append(String.Format("ItemType: {0}", ItemType));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public uint X;
|
|
public uint Y;
|
|
public UUID ID;
|
|
public int Extra;
|
|
public int Extra2;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 32;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
X = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Y = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
Extra = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Extra2 = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(X, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Y, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(Extra, bytes, i); i += 4;
|
|
Utils.IntToBytes(Extra2, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("X: {0}", X));
|
|
output.AppendLine(String.Format("Y: {0}", Y));
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("Extra: {0}", Extra));
|
|
output.AppendLine(String.Format("Extra2: {0}", Extra2));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MapItemReply; } }
|
|
public AgentDataBlock AgentData;
|
|
public RequestDataBlock RequestData;
|
|
public DataBlock[] Data;
|
|
|
|
public MapItemReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 411;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RequestData = new RequestDataBlock();
|
|
Data = new DataBlock[0];
|
|
}
|
|
|
|
public MapItemReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MapItemReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Data.Length < count) {
|
|
Data = new DataBlock[count];
|
|
for(int j = 0; j < count; j++) Data[j] = new DataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Data[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RequestData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RequestData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Data.Length;
|
|
for (int j = 0; j < Data.Length; j++) { Data[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MapItemReply ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RequestData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Data.Length; j++)
|
|
{
|
|
output += Data[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SendPostcardPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID AssetID;
|
|
public Vector3d PosGlobal;
|
|
private byte[] _to;
|
|
public byte[] To
|
|
{
|
|
get { return _to; }
|
|
set
|
|
{
|
|
if (value == null) { _to = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _to = new byte[value.Length]; Buffer.BlockCopy(value, 0, _to, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _from;
|
|
public byte[] From
|
|
{
|
|
get { return _from; }
|
|
set
|
|
{
|
|
if (value == null) { _from = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _from = new byte[value.Length]; Buffer.BlockCopy(value, 0, _from, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _subject;
|
|
public byte[] Subject
|
|
{
|
|
get { return _subject; }
|
|
set
|
|
{
|
|
if (value == null) { _subject = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _subject = new byte[value.Length]; Buffer.BlockCopy(value, 0, _subject, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _msg;
|
|
public byte[] Msg
|
|
{
|
|
get { return _msg; }
|
|
set
|
|
{
|
|
if (value == null) { _msg = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _msg = new byte[value.Length]; Buffer.BlockCopy(value, 0, _msg, 0, value.Length); }
|
|
}
|
|
}
|
|
public bool AllowPublish;
|
|
public bool MaturePublish;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 74;
|
|
if (To != null) { length += 1 + To.Length; }
|
|
if (From != null) { length += 1 + From.Length; }
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Subject != null) { length += 1 + Subject.Length; }
|
|
if (Msg != null) { length += 2 + Msg.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
AssetID.FromBytes(bytes, i); i += 16;
|
|
PosGlobal.FromBytes(bytes, i); i += 24;
|
|
length = (ushort)bytes[i++];
|
|
_to = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _to, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_from = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _from, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_subject = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _subject, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_msg = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _msg, 0, length); i += length;
|
|
AllowPublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
MaturePublish = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AssetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(PosGlobal.GetBytes(), 0, bytes, i, 24); i += 24;
|
|
if(To == null) { Console.WriteLine("Warning: To is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)To.Length;
|
|
Buffer.BlockCopy(To, 0, bytes, i, To.Length); i += To.Length;
|
|
if(From == null) { Console.WriteLine("Warning: From is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)From.Length;
|
|
Buffer.BlockCopy(From, 0, bytes, i, From.Length); i += From.Length;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Subject == null) { Console.WriteLine("Warning: Subject is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Subject.Length;
|
|
Buffer.BlockCopy(Subject, 0, bytes, i, Subject.Length); i += Subject.Length;
|
|
if(Msg == null) { Console.WriteLine("Warning: Msg is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Msg.Length % 256);
|
|
bytes[i++] = (byte)((Msg.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Msg, 0, bytes, i, Msg.Length); i += Msg.Length;
|
|
bytes[i++] = (byte)((AllowPublish) ? 1 : 0);
|
|
bytes[i++] = (byte)((MaturePublish) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("AssetID: {0}", AssetID));
|
|
output.AppendLine(String.Format("PosGlobal: {0}", PosGlobal));
|
|
Helpers.FieldToString(output, To, "To");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, From, "From");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Subject, "Subject");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Msg, "Msg");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("AllowPublish: {0}", AllowPublish));
|
|
output.Append(String.Format("MaturePublish: {0}", MaturePublish));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SendPostcard; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public SendPostcardPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 412;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public SendPostcardPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SendPostcardPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SendPostcard ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelMediaCommandMessagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class CommandBlockBlock : PacketBlock
|
|
{
|
|
public uint Flags;
|
|
public uint Command;
|
|
public float Time;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public CommandBlockBlock() { }
|
|
public CommandBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Flags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Command = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Time = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(Flags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Command, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Time, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- CommandBlock --");
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("Command: {0}", Command));
|
|
output.Append(String.Format("Time: {0}", Time));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelMediaCommandMessage; } }
|
|
public CommandBlockBlock CommandBlock;
|
|
|
|
public ParcelMediaCommandMessagePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 419;
|
|
Header.Reliable = true;
|
|
CommandBlock = new CommandBlockBlock();
|
|
}
|
|
|
|
public ParcelMediaCommandMessagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CommandBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelMediaCommandMessagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CommandBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += CommandBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
CommandBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelMediaCommandMessage ---" + Environment.NewLine;
|
|
output += CommandBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelMediaUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
private byte[] _mediaurl;
|
|
public byte[] MediaURL
|
|
{
|
|
get { return _mediaurl; }
|
|
set
|
|
{
|
|
if (value == null) { _mediaurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID MediaID;
|
|
public byte MediaAutoScale;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 17;
|
|
if (MediaURL != null) { length += 1 + MediaURL.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_mediaurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
|
|
MediaID.FromBytes(bytes, i); i += 16;
|
|
MediaAutoScale = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaURL.Length;
|
|
Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
|
|
Buffer.BlockCopy(MediaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = MediaAutoScale;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
Helpers.FieldToString(output, MediaURL, "MediaURL");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("MediaID: {0}", MediaID));
|
|
output.Append(String.Format("MediaAutoScale: {0}", MediaAutoScale));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlockExtendedBlock : PacketBlock
|
|
{
|
|
private byte[] _mediatype;
|
|
public byte[] MediaType
|
|
{
|
|
get { return _mediatype; }
|
|
set
|
|
{
|
|
if (value == null) { _mediatype = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediatype = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediatype, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _mediadesc;
|
|
public byte[] MediaDesc
|
|
{
|
|
get { return _mediadesc; }
|
|
set
|
|
{
|
|
if (value == null) { _mediadesc = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediadesc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediadesc, 0, value.Length); }
|
|
}
|
|
}
|
|
public int MediaWidth;
|
|
public int MediaHeight;
|
|
public byte MediaLoop;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 9;
|
|
if (MediaType != null) { length += 1 + MediaType.Length; }
|
|
if (MediaDesc != null) { length += 1 + MediaDesc.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlockExtendedBlock() { }
|
|
public DataBlockExtendedBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_mediatype = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediatype, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_mediadesc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediadesc, 0, length); i += length;
|
|
MediaWidth = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
MediaHeight = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
MediaLoop = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(MediaType == null) { Console.WriteLine("Warning: MediaType is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaType.Length;
|
|
Buffer.BlockCopy(MediaType, 0, bytes, i, MediaType.Length); i += MediaType.Length;
|
|
if(MediaDesc == null) { Console.WriteLine("Warning: MediaDesc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaDesc.Length;
|
|
Buffer.BlockCopy(MediaDesc, 0, bytes, i, MediaDesc.Length); i += MediaDesc.Length;
|
|
Utils.IntToBytes(MediaWidth, bytes, i); i += 4;
|
|
Utils.IntToBytes(MediaHeight, bytes, i); i += 4;
|
|
bytes[i++] = MediaLoop;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlockExtended --");
|
|
Helpers.FieldToString(output, MediaType, "MediaType");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, MediaDesc, "MediaDesc");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("MediaWidth: {0}", MediaWidth));
|
|
output.AppendLine(String.Format("MediaHeight: {0}", MediaHeight));
|
|
output.Append(String.Format("MediaLoop: {0}", MediaLoop));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelMediaUpdate; } }
|
|
public DataBlockBlock DataBlock;
|
|
public DataBlockExtendedBlock DataBlockExtended;
|
|
|
|
public ParcelMediaUpdatePacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 420;
|
|
Header.Reliable = true;
|
|
DataBlock = new DataBlockBlock();
|
|
DataBlockExtended = new DataBlockExtendedBlock();
|
|
}
|
|
|
|
public ParcelMediaUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
DataBlockExtended.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelMediaUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
DataBlockExtended.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += DataBlock.Length; length += DataBlockExtended.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
DataBlockExtended.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelMediaUpdate ---" + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
output += DataBlockExtended.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LandStatRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestDataBlock : PacketBlock
|
|
{
|
|
public uint ReportType;
|
|
public uint RequestFlags;
|
|
private byte[] _filter;
|
|
public byte[] Filter
|
|
{
|
|
get { return _filter; }
|
|
set
|
|
{
|
|
if (value == null) { _filter = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _filter = new byte[value.Length]; Buffer.BlockCopy(value, 0, _filter, 0, value.Length); }
|
|
}
|
|
}
|
|
public int ParcelLocalID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 12;
|
|
if (Filter != null) { length += 1 + Filter.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RequestDataBlock() { }
|
|
public RequestDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ReportType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_filter = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _filter, 0, length); i += length;
|
|
ParcelLocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ReportType, bytes, i); i += 4;
|
|
Utils.UIntToBytes(RequestFlags, bytes, i); i += 4;
|
|
if(Filter == null) { Console.WriteLine("Warning: Filter is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Filter.Length;
|
|
Buffer.BlockCopy(Filter, 0, bytes, i, Filter.Length); i += Filter.Length;
|
|
Utils.IntToBytes(ParcelLocalID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestData --");
|
|
output.AppendLine(String.Format("ReportType: {0}", ReportType));
|
|
output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
|
|
Helpers.FieldToString(output, Filter, "Filter");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("ParcelLocalID: {0}", ParcelLocalID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LandStatRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public RequestDataBlock RequestData;
|
|
|
|
public LandStatRequestPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 421;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RequestData = new RequestDataBlock();
|
|
}
|
|
|
|
public LandStatRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LandStatRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RequestData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += RequestData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RequestData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LandStatRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RequestData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LandStatReplyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RequestDataBlock : PacketBlock
|
|
{
|
|
public uint ReportType;
|
|
public uint RequestFlags;
|
|
public uint TotalObjectCount;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public RequestDataBlock() { }
|
|
public RequestDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ReportType = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TotalObjectCount = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ReportType, bytes, i); i += 4;
|
|
Utils.UIntToBytes(RequestFlags, bytes, i); i += 4;
|
|
Utils.UIntToBytes(TotalObjectCount, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestData --");
|
|
output.AppendLine(String.Format("ReportType: {0}", ReportType));
|
|
output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
|
|
output.Append(String.Format("TotalObjectCount: {0}", TotalObjectCount));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ReportDataBlock : PacketBlock
|
|
{
|
|
public uint TaskLocalID;
|
|
public UUID TaskID;
|
|
public float LocationX;
|
|
public float LocationY;
|
|
public float LocationZ;
|
|
public float Score;
|
|
private byte[] _taskname;
|
|
public byte[] TaskName
|
|
{
|
|
get { return _taskname; }
|
|
set
|
|
{
|
|
if (value == null) { _taskname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _taskname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _taskname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _ownername;
|
|
public byte[] OwnerName
|
|
{
|
|
get { return _ownername; }
|
|
set
|
|
{
|
|
if (value == null) { _ownername = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _ownername = new byte[value.Length]; Buffer.BlockCopy(value, 0, _ownername, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 36;
|
|
if (TaskName != null) { length += 1 + TaskName.Length; }
|
|
if (OwnerName != null) { length += 1 + OwnerName.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ReportDataBlock() { }
|
|
public ReportDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TaskLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TaskID.FromBytes(bytes, i); i += 16;
|
|
LocationX = Utils.BytesToFloat(bytes, i); i += 4;
|
|
LocationY = Utils.BytesToFloat(bytes, i); i += 4;
|
|
LocationZ = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Score = Utils.BytesToFloat(bytes, i); i += 4;
|
|
length = (ushort)bytes[i++];
|
|
_taskname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _taskname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_ownername = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _ownername, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(TaskLocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(TaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(LocationX, bytes, i); i += 4;
|
|
Utils.FloatToBytes(LocationY, bytes, i); i += 4;
|
|
Utils.FloatToBytes(LocationZ, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Score, bytes, i); i += 4;
|
|
if(TaskName == null) { Console.WriteLine("Warning: TaskName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TaskName.Length;
|
|
Buffer.BlockCopy(TaskName, 0, bytes, i, TaskName.Length); i += TaskName.Length;
|
|
if(OwnerName == null) { Console.WriteLine("Warning: OwnerName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)OwnerName.Length;
|
|
Buffer.BlockCopy(OwnerName, 0, bytes, i, OwnerName.Length); i += OwnerName.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ReportData --");
|
|
output.AppendLine(String.Format("TaskLocalID: {0}", TaskLocalID));
|
|
output.AppendLine(String.Format("TaskID: {0}", TaskID));
|
|
output.AppendLine(String.Format("LocationX: {0}", LocationX));
|
|
output.AppendLine(String.Format("LocationY: {0}", LocationY));
|
|
output.AppendLine(String.Format("LocationZ: {0}", LocationZ));
|
|
output.AppendLine(String.Format("Score: {0}", Score));
|
|
Helpers.FieldToString(output, TaskName, "TaskName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, OwnerName, "OwnerName");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LandStatReply; } }
|
|
public RequestDataBlock RequestData;
|
|
public ReportDataBlock[] ReportData;
|
|
|
|
public LandStatReplyPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 422;
|
|
Header.Reliable = true;
|
|
RequestData = new RequestDataBlock();
|
|
ReportData = new ReportDataBlock[0];
|
|
}
|
|
|
|
public LandStatReplyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RequestData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ReportData.Length < count) {
|
|
ReportData = new ReportDataBlock[count];
|
|
for(int j = 0; j < count; j++) ReportData[j] = new ReportDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ReportData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public LandStatReplyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RequestData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ReportData.Length < count) {
|
|
ReportData = new ReportDataBlock[count];
|
|
for(int j = 0; j < count; j++) ReportData[j] = new ReportDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ReportData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += RequestData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ReportData.Length; j++) { length += ReportData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RequestData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ReportData.Length;
|
|
for (int j = 0; j < ReportData.Length; j++) { ReportData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LandStatReply ---" + Environment.NewLine;
|
|
output += RequestData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ReportData.Length; j++)
|
|
{
|
|
output += ReportData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ErrorPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataBlock : PacketBlock
|
|
{
|
|
public int Code;
|
|
private byte[] _token;
|
|
public byte[] Token
|
|
{
|
|
get { return _token; }
|
|
set
|
|
{
|
|
if (value == null) { _token = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _token = new byte[value.Length]; Buffer.BlockCopy(value, 0, _token, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID ID;
|
|
private byte[] _system;
|
|
public byte[] System
|
|
{
|
|
get { return _system; }
|
|
set
|
|
{
|
|
if (value == null) { _system = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _system = new byte[value.Length]; Buffer.BlockCopy(value, 0, _system, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _message;
|
|
public byte[] Message
|
|
{
|
|
get { return _message; }
|
|
set
|
|
{
|
|
if (value == null) { _message = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _message = new byte[value.Length]; Buffer.BlockCopy(value, 0, _message, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 20;
|
|
if (Token != null) { length += 1 + Token.Length; }
|
|
if (System != null) { length += 1 + System.Length; }
|
|
if (Message != null) { length += 2 + Message.Length; }
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataBlock() { }
|
|
public DataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
Code = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_token = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _token, 0, length); i += length;
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_system = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _system, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_message = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _message, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(Code, bytes, i); i += 4;
|
|
if(Token == null) { Console.WriteLine("Warning: Token is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Token.Length;
|
|
Buffer.BlockCopy(Token, 0, bytes, i, Token.Length); i += Token.Length;
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(System == null) { Console.WriteLine("Warning: System is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)System.Length;
|
|
Buffer.BlockCopy(System, 0, bytes, i, System.Length); i += System.Length;
|
|
if(Message == null) { Console.WriteLine("Warning: Message is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Message.Length % 256);
|
|
bytes[i++] = (byte)((Message.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Message, 0, bytes, i, Message.Length); i += Message.Length;
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Data --");
|
|
output.AppendLine(String.Format("Code: {0}", Code));
|
|
Helpers.FieldToString(output, Token, "Token");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
Helpers.FieldToString(output, System, "System");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Message, "Message");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.Error; } }
|
|
public AgentDataBlock AgentData;
|
|
public DataBlock Data;
|
|
|
|
public ErrorPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 423;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Data = new DataBlock();
|
|
}
|
|
|
|
public ErrorPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ErrorPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
Data.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length; length += Data.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
Data.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- Error ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += Data.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectIncludeInSearchPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public bool IncludeInSearch;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
IncludeInSearch = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((IncludeInSearch) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("IncludeInSearch: {0}", IncludeInSearch));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectIncludeInSearch; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectIncludeInSearchPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 424;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectIncludeInSearchPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectIncludeInSearchPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectIncludeInSearch ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PacketAckPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class PacketsBlock : PacketBlock
|
|
{
|
|
public uint ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public PacketsBlock() { }
|
|
public PacketsBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Packets --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PacketAck; } }
|
|
public PacketsBlock[] Packets;
|
|
|
|
public PacketAckPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 65531;
|
|
Header.Reliable = true;
|
|
Packets = new PacketsBlock[0];
|
|
}
|
|
|
|
public PacketAckPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Packets.Length < count) {
|
|
Packets = new PacketsBlock[count];
|
|
for(int j = 0; j < count; j++) Packets[j] = new PacketsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Packets[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public PacketAckPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Packets.Length < count) {
|
|
Packets = new PacketsBlock[count];
|
|
for(int j = 0; j < count; j++) Packets[j] = new PacketsBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Packets[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < Packets.Length; j++) { length += Packets[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Packets.Length;
|
|
for (int j = 0; j < Packets.Length; j++) { Packets[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PacketAck ---" + Environment.NewLine;
|
|
for (int j = 0; j < Packets.Length; j++)
|
|
{
|
|
output += Packets[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class OpenCircuitPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class CircuitInfoBlock : PacketBlock
|
|
{
|
|
public uint IP;
|
|
public ushort Port;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
public CircuitInfoBlock() { }
|
|
public CircuitInfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
IP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Port = (ushort)((bytes[i++] << 8) + bytes[i++]);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(IP, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((Port >> 8) % 256);
|
|
bytes[i++] = (byte)(Port % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- CircuitInfo --");
|
|
output.AppendLine(String.Format("IP: {0}", IP));
|
|
output.Append(String.Format("Port: {0}", Port));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.OpenCircuit; } }
|
|
public CircuitInfoBlock CircuitInfo;
|
|
|
|
public OpenCircuitPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 65532;
|
|
Header.Reliable = true;
|
|
CircuitInfo = new CircuitInfoBlock();
|
|
}
|
|
|
|
public OpenCircuitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CircuitInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public OpenCircuitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CircuitInfo.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
length += CircuitInfo.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
CircuitInfo.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- OpenCircuit ---" + Environment.NewLine;
|
|
output += CircuitInfo.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CloseCircuitPacket : Packet
|
|
{
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CloseCircuit; } }
|
|
|
|
public CloseCircuitPacket()
|
|
{
|
|
Header = new LowHeader();
|
|
Header.ID = 65533;
|
|
Header.Reliable = true;
|
|
}
|
|
|
|
public CloseCircuitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public CloseCircuitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 10;
|
|
;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CloseCircuit ---" + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectAddPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public UUID GroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.Append(String.Format("GroupID: {0}", GroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public byte PCode;
|
|
public byte Material;
|
|
public uint AddFlags;
|
|
public byte PathCurve;
|
|
public byte ProfileCurve;
|
|
public ushort PathBegin;
|
|
public ushort PathEnd;
|
|
public byte PathScaleX;
|
|
public byte PathScaleY;
|
|
public byte PathShearX;
|
|
public byte PathShearY;
|
|
public sbyte PathTwist;
|
|
public sbyte PathTwistBegin;
|
|
public sbyte PathRadiusOffset;
|
|
public sbyte PathTaperX;
|
|
public sbyte PathTaperY;
|
|
public byte PathRevolutions;
|
|
public sbyte PathSkew;
|
|
public ushort ProfileBegin;
|
|
public ushort ProfileEnd;
|
|
public ushort ProfileHollow;
|
|
public byte BypassRaycast;
|
|
public Vector3 RayStart;
|
|
public Vector3 RayEnd;
|
|
public UUID RayTargetID;
|
|
public byte RayEndIsIntersection;
|
|
public Vector3 Scale;
|
|
public Quaternion Rotation;
|
|
public byte State;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 96;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PCode = (byte)bytes[i++];
|
|
Material = (byte)bytes[i++];
|
|
AddFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PathCurve = (byte)bytes[i++];
|
|
ProfileCurve = (byte)bytes[i++];
|
|
PathBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
PathEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
PathScaleX = (byte)bytes[i++];
|
|
PathScaleY = (byte)bytes[i++];
|
|
PathShearX = (byte)bytes[i++];
|
|
PathShearY = (byte)bytes[i++];
|
|
PathTwist = (sbyte)bytes[i++];
|
|
PathTwistBegin = (sbyte)bytes[i++];
|
|
PathRadiusOffset = (sbyte)bytes[i++];
|
|
PathTaperX = (sbyte)bytes[i++];
|
|
PathTaperY = (sbyte)bytes[i++];
|
|
PathRevolutions = (byte)bytes[i++];
|
|
PathSkew = (sbyte)bytes[i++];
|
|
ProfileBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ProfileEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ProfileHollow = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
BypassRaycast = (byte)bytes[i++];
|
|
RayStart.FromBytes(bytes, i); i += 12;
|
|
RayEnd.FromBytes(bytes, i); i += 12;
|
|
RayTargetID.FromBytes(bytes, i); i += 16;
|
|
RayEndIsIntersection = (byte)bytes[i++];
|
|
Scale.FromBytes(bytes, i); i += 12;
|
|
Rotation.FromBytes(bytes, i, true); i += 12;
|
|
State = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = PCode;
|
|
bytes[i++] = Material;
|
|
Utils.UIntToBytes(AddFlags, bytes, i); i += 4;
|
|
bytes[i++] = PathCurve;
|
|
bytes[i++] = ProfileCurve;
|
|
bytes[i++] = (byte)(PathBegin % 256);
|
|
bytes[i++] = (byte)((PathBegin >> 8) % 256);
|
|
bytes[i++] = (byte)(PathEnd % 256);
|
|
bytes[i++] = (byte)((PathEnd >> 8) % 256);
|
|
bytes[i++] = PathScaleX;
|
|
bytes[i++] = PathScaleY;
|
|
bytes[i++] = PathShearX;
|
|
bytes[i++] = PathShearY;
|
|
bytes[i++] = (byte)PathTwist;
|
|
bytes[i++] = (byte)PathTwistBegin;
|
|
bytes[i++] = (byte)PathRadiusOffset;
|
|
bytes[i++] = (byte)PathTaperX;
|
|
bytes[i++] = (byte)PathTaperY;
|
|
bytes[i++] = PathRevolutions;
|
|
bytes[i++] = (byte)PathSkew;
|
|
bytes[i++] = (byte)(ProfileBegin % 256);
|
|
bytes[i++] = (byte)((ProfileBegin >> 8) % 256);
|
|
bytes[i++] = (byte)(ProfileEnd % 256);
|
|
bytes[i++] = (byte)((ProfileEnd >> 8) % 256);
|
|
bytes[i++] = (byte)(ProfileHollow % 256);
|
|
bytes[i++] = (byte)((ProfileHollow >> 8) % 256);
|
|
bytes[i++] = BypassRaycast;
|
|
Buffer.BlockCopy(RayStart.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayEnd.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(RayTargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = RayEndIsIntersection;
|
|
Buffer.BlockCopy(Scale.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Rotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = State;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("PCode: {0}", PCode));
|
|
output.AppendLine(String.Format("Material: {0}", Material));
|
|
output.AppendLine(String.Format("AddFlags: {0}", AddFlags));
|
|
output.AppendLine(String.Format("PathCurve: {0}", PathCurve));
|
|
output.AppendLine(String.Format("ProfileCurve: {0}", ProfileCurve));
|
|
output.AppendLine(String.Format("PathBegin: {0}", PathBegin));
|
|
output.AppendLine(String.Format("PathEnd: {0}", PathEnd));
|
|
output.AppendLine(String.Format("PathScaleX: {0}", PathScaleX));
|
|
output.AppendLine(String.Format("PathScaleY: {0}", PathScaleY));
|
|
output.AppendLine(String.Format("PathShearX: {0}", PathShearX));
|
|
output.AppendLine(String.Format("PathShearY: {0}", PathShearY));
|
|
output.AppendLine(String.Format("PathTwist: {0}", PathTwist));
|
|
output.AppendLine(String.Format("PathTwistBegin: {0}", PathTwistBegin));
|
|
output.AppendLine(String.Format("PathRadiusOffset: {0}", PathRadiusOffset));
|
|
output.AppendLine(String.Format("PathTaperX: {0}", PathTaperX));
|
|
output.AppendLine(String.Format("PathTaperY: {0}", PathTaperY));
|
|
output.AppendLine(String.Format("PathRevolutions: {0}", PathRevolutions));
|
|
output.AppendLine(String.Format("PathSkew: {0}", PathSkew));
|
|
output.AppendLine(String.Format("ProfileBegin: {0}", ProfileBegin));
|
|
output.AppendLine(String.Format("ProfileEnd: {0}", ProfileEnd));
|
|
output.AppendLine(String.Format("ProfileHollow: {0}", ProfileHollow));
|
|
output.AppendLine(String.Format("BypassRaycast: {0}", BypassRaycast));
|
|
output.AppendLine(String.Format("RayStart: {0}", RayStart));
|
|
output.AppendLine(String.Format("RayEnd: {0}", RayEnd));
|
|
output.AppendLine(String.Format("RayTargetID: {0}", RayTargetID));
|
|
output.AppendLine(String.Format("RayEndIsIntersection: {0}", RayEndIsIntersection));
|
|
output.AppendLine(String.Format("Scale: {0}", Scale));
|
|
output.AppendLine(String.Format("Rotation: {0}", Rotation));
|
|
output.Append(String.Format("State: {0}", State));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectAdd; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public ObjectAddPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 1;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public ObjectAddPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ObjectAddPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectAdd ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class MultipleObjectUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public byte Type;
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 5;
|
|
if (Data != null) { length += 1 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Type = (byte)bytes[i++];
|
|
length = (ushort)bytes[i++];
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
bytes[i++] = Type;
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Data.Length;
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.MultipleObjectUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public MultipleObjectUpdatePacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 2;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public MultipleObjectUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public MultipleObjectUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- MultipleObjectUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestMultipleObjectsPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public byte CacheMissType;
|
|
public uint ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
CacheMissType = (byte)bytes[i++];
|
|
ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = CacheMissType;
|
|
Utils.UIntToBytes(ID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("CacheMissType: {0}", CacheMissType));
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestMultipleObjects; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public RequestMultipleObjectsPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 3;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public RequestMultipleObjectsPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RequestMultipleObjectsPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestMultipleObjects ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectPositionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ObjectLocalID;
|
|
public Vector3 Position;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectLocalID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ObjectLocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectLocalID: {0}", ObjectLocalID));
|
|
output.Append(String.Format("Position: {0}", Position));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectPosition; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectPositionPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 4;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectPositionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectPositionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectPosition ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestObjectPropertiesFamilyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint RequestFlags;
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(RequestFlags, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestObjectPropertiesFamily; } }
|
|
public AgentDataBlock AgentData;
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public RequestObjectPropertiesFamilyPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 5;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public RequestObjectPropertiesFamilyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public RequestObjectPropertiesFamilyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length; length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestObjectPropertiesFamily ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CoarseLocationUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class LocationBlock : PacketBlock
|
|
{
|
|
public byte X;
|
|
public byte Y;
|
|
public byte Z;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 3;
|
|
}
|
|
}
|
|
|
|
public LocationBlock() { }
|
|
public LocationBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
X = (byte)bytes[i++];
|
|
Y = (byte)bytes[i++];
|
|
Z = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = X;
|
|
bytes[i++] = Y;
|
|
bytes[i++] = Z;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Location --");
|
|
output.AppendLine(String.Format("X: {0}", X));
|
|
output.AppendLine(String.Format("Y: {0}", Y));
|
|
output.Append(String.Format("Z: {0}", Z));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class IndexBlock : PacketBlock
|
|
{
|
|
public short You;
|
|
public short Prey;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public IndexBlock() { }
|
|
public IndexBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
You = (short)(bytes[i++] + (bytes[i++] << 8));
|
|
Prey = (short)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)(You % 256);
|
|
bytes[i++] = (byte)((You >> 8) % 256);
|
|
bytes[i++] = (byte)(Prey % 256);
|
|
bytes[i++] = (byte)((Prey >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Index --");
|
|
output.AppendLine(String.Format("You: {0}", You));
|
|
output.Append(String.Format("Prey: {0}", Prey));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.Append(String.Format("AgentID: {0}", AgentID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CoarseLocationUpdate; } }
|
|
public LocationBlock[] Location;
|
|
public IndexBlock Index;
|
|
public AgentDataBlock[] AgentData;
|
|
|
|
public CoarseLocationUpdatePacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 6;
|
|
Header.Reliable = true;
|
|
Location = new LocationBlock[0];
|
|
Index = new IndexBlock();
|
|
AgentData = new AgentDataBlock[0];
|
|
}
|
|
|
|
public CoarseLocationUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Location.Length < count) {
|
|
Location = new LocationBlock[count];
|
|
for(int j = 0; j < count; j++) Location[j] = new LocationBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Location[j].FromBytes(bytes, ref i); }
|
|
Index.FromBytes(bytes, ref i);
|
|
count = (int)bytes[i++];
|
|
if(AgentData.Length < count) {
|
|
AgentData = new AgentDataBlock[count];
|
|
for(int j = 0; j < count; j++) AgentData[j] = new AgentDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public CoarseLocationUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(Location.Length < count) {
|
|
Location = new LocationBlock[count];
|
|
for(int j = 0; j < count; j++) Location[j] = new LocationBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Location[j].FromBytes(bytes, ref i); }
|
|
Index.FromBytes(bytes, ref i);
|
|
count = (int)bytes[i++];
|
|
if(AgentData.Length < count) {
|
|
AgentData = new AgentDataBlock[count];
|
|
for(int j = 0; j < count; j++) AgentData[j] = new AgentDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AgentData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += Index.Length;;
|
|
length++;
|
|
for (int j = 0; j < Location.Length; j++) { length += Location[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < AgentData.Length; j++) { length += AgentData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Location.Length;
|
|
for (int j = 0; j < Location.Length; j++) { Location[j].ToBytes(bytes, ref i); }
|
|
Index.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)AgentData.Length;
|
|
for (int j = 0; j < AgentData.Length; j++) { AgentData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CoarseLocationUpdate ---" + Environment.NewLine;
|
|
for (int j = 0; j < Location.Length; j++)
|
|
{
|
|
output += Location[j].ToString() + Environment.NewLine;
|
|
}
|
|
output += Index.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < AgentData.Length; j++)
|
|
{
|
|
output += AgentData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CrossedRegionPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RegionDataBlock : PacketBlock
|
|
{
|
|
public uint SimIP;
|
|
public ushort SimPort;
|
|
public ulong RegionHandle;
|
|
private byte[] _seedcapability;
|
|
public byte[] SeedCapability
|
|
{
|
|
get { return _seedcapability; }
|
|
set
|
|
{
|
|
if (value == null) { _seedcapability = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _seedcapability = new byte[value.Length]; Buffer.BlockCopy(value, 0, _seedcapability, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 14;
|
|
if (SeedCapability != null) { length += 2 + SeedCapability.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public RegionDataBlock() { }
|
|
public RegionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
SimIP = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SimPort = (ushort)((bytes[i++] << 8) + bytes[i++]);
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_seedcapability = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _seedcapability, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(SimIP, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((SimPort >> 8) % 256);
|
|
bytes[i++] = (byte)(SimPort % 256);
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
if(SeedCapability == null) { Console.WriteLine("Warning: SeedCapability is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(SeedCapability.Length % 256);
|
|
bytes[i++] = (byte)((SeedCapability.Length >> 8) % 256);
|
|
Buffer.BlockCopy(SeedCapability, 0, bytes, i, SeedCapability.Length); i += SeedCapability.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionData --");
|
|
output.AppendLine(String.Format("SimIP: {0}", SimIP));
|
|
output.AppendLine(String.Format("SimPort: {0}", SimPort));
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
Helpers.FieldToString(output, SeedCapability, "SeedCapability");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class InfoBlock : PacketBlock
|
|
{
|
|
public Vector3 Position;
|
|
public Vector3 LookAt;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 24;
|
|
}
|
|
}
|
|
|
|
public InfoBlock() { }
|
|
public InfoBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
LookAt.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Info --");
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.Append(String.Format("LookAt: {0}", LookAt));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CrossedRegion; } }
|
|
public AgentDataBlock AgentData;
|
|
public RegionDataBlock RegionData;
|
|
public InfoBlock Info;
|
|
|
|
public CrossedRegionPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 7;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RegionData = new RegionDataBlock();
|
|
Info = new InfoBlock();
|
|
}
|
|
|
|
public CrossedRegionPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CrossedRegionPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
RegionData.FromBytes(bytes, ref i);
|
|
Info.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length; length += RegionData.Length; length += Info.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
RegionData.ToBytes(bytes, ref i);
|
|
Info.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CrossedRegion ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += RegionData.ToString() + Environment.NewLine;
|
|
output += Info.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ConfirmEnableSimulatorPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ConfirmEnableSimulator; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ConfirmEnableSimulatorPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 8;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ConfirmEnableSimulatorPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ConfirmEnableSimulatorPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ConfirmEnableSimulator ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectPropertiesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID CreatorID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public ulong CreationDate;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public int OwnershipCost;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
public byte AggregatePerms;
|
|
public byte AggregatePermTextures;
|
|
public byte AggregatePermTexturesOwner;
|
|
public uint Category;
|
|
public short InventorySerial;
|
|
public UUID ItemID;
|
|
public UUID FolderID;
|
|
public UUID FromTaskID;
|
|
public UUID LastOwnerID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _touchname;
|
|
public byte[] TouchName
|
|
{
|
|
get { return _touchname; }
|
|
set
|
|
{
|
|
if (value == null) { _touchname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _touchname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _touchname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _sitname;
|
|
public byte[] SitName
|
|
{
|
|
get { return _sitname; }
|
|
set
|
|
{
|
|
if (value == null) { _sitname = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _sitname = new byte[value.Length]; Buffer.BlockCopy(value, 0, _sitname, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _textureid;
|
|
public byte[] TextureID
|
|
{
|
|
get { return _textureid; }
|
|
set
|
|
{
|
|
if (value == null) { _textureid = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _textureid = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureid, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 174;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
if (TouchName != null) { length += 1 + TouchName.Length; }
|
|
if (SitName != null) { length += 1 + SitName.Length; }
|
|
if (TextureID != null) { length += 1 + TextureID.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
CreatorID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
CreationDate = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnershipCost = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AggregatePerms = (byte)bytes[i++];
|
|
AggregatePermTextures = (byte)bytes[i++];
|
|
AggregatePermTexturesOwner = (byte)bytes[i++];
|
|
Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
InventorySerial = (short)(bytes[i++] + (bytes[i++] << 8));
|
|
ItemID.FromBytes(bytes, i); i += 16;
|
|
FolderID.FromBytes(bytes, i); i += 16;
|
|
FromTaskID.FromBytes(bytes, i); i += 16;
|
|
LastOwnerID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_touchname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _touchname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_sitname = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _sitname, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_textureid = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureid, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(CreatorID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(CreationDate, bytes, i); i += 8;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
Utils.IntToBytes(OwnershipCost, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
bytes[i++] = AggregatePerms;
|
|
bytes[i++] = AggregatePermTextures;
|
|
bytes[i++] = AggregatePermTexturesOwner;
|
|
Utils.UIntToBytes(Category, bytes, i); i += 4;
|
|
bytes[i++] = (byte)(InventorySerial % 256);
|
|
bytes[i++] = (byte)((InventorySerial >> 8) % 256);
|
|
Buffer.BlockCopy(ItemID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FolderID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(FromTaskID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(LastOwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
if(TouchName == null) { Console.WriteLine("Warning: TouchName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TouchName.Length;
|
|
Buffer.BlockCopy(TouchName, 0, bytes, i, TouchName.Length); i += TouchName.Length;
|
|
if(SitName == null) { Console.WriteLine("Warning: SitName is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)SitName.Length;
|
|
Buffer.BlockCopy(SitName, 0, bytes, i, SitName.Length); i += SitName.Length;
|
|
if(TextureID == null) { Console.WriteLine("Warning: TextureID is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TextureID.Length;
|
|
Buffer.BlockCopy(TextureID, 0, bytes, i, TextureID.Length); i += TextureID.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("CreatorID: {0}", CreatorID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("CreationDate: {0}", CreationDate));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("OwnershipCost: {0}", OwnershipCost));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
output.AppendLine(String.Format("AggregatePerms: {0}", AggregatePerms));
|
|
output.AppendLine(String.Format("AggregatePermTextures: {0}", AggregatePermTextures));
|
|
output.AppendLine(String.Format("AggregatePermTexturesOwner: {0}", AggregatePermTexturesOwner));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
output.AppendLine(String.Format("InventorySerial: {0}", InventorySerial));
|
|
output.AppendLine(String.Format("ItemID: {0}", ItemID));
|
|
output.AppendLine(String.Format("FolderID: {0}", FolderID));
|
|
output.AppendLine(String.Format("FromTaskID: {0}", FromTaskID));
|
|
output.AppendLine(String.Format("LastOwnerID: {0}", LastOwnerID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TouchName, "TouchName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, SitName, "SitName");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TextureID, "TextureID");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectProperties; } }
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectPropertiesPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 9;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectPropertiesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectPropertiesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectProperties ---" + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectPropertiesFamilyPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint RequestFlags;
|
|
public UUID ObjectID;
|
|
public UUID OwnerID;
|
|
public UUID GroupID;
|
|
public uint BaseMask;
|
|
public uint OwnerMask;
|
|
public uint GroupMask;
|
|
public uint EveryoneMask;
|
|
public uint NextOwnerMask;
|
|
public int OwnershipCost;
|
|
public byte SaleType;
|
|
public int SalePrice;
|
|
public uint Category;
|
|
public UUID LastOwnerID;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _description;
|
|
public byte[] Description
|
|
{
|
|
get { return _description; }
|
|
set
|
|
{
|
|
if (value == null) { _description = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _description = new byte[value.Length]; Buffer.BlockCopy(value, 0, _description, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 101;
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Description != null) { length += 1 + Description.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RequestFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
BaseMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EveryoneMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
NextOwnerMask = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnershipCost = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SaleType = (byte)bytes[i++];
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Category = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LastOwnerID.FromBytes(bytes, i); i += 16;
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_description = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _description, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(RequestFlags, bytes, i); i += 4;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(BaseMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(OwnerMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(GroupMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(EveryoneMask, bytes, i); i += 4;
|
|
Utils.UIntToBytes(NextOwnerMask, bytes, i); i += 4;
|
|
Utils.IntToBytes(OwnershipCost, bytes, i); i += 4;
|
|
bytes[i++] = SaleType;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Category, bytes, i); i += 4;
|
|
Buffer.BlockCopy(LastOwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Description == null) { Console.WriteLine("Warning: Description is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Description.Length;
|
|
Buffer.BlockCopy(Description, 0, bytes, i, Description.Length); i += Description.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("RequestFlags: {0}", RequestFlags));
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("BaseMask: {0}", BaseMask));
|
|
output.AppendLine(String.Format("OwnerMask: {0}", OwnerMask));
|
|
output.AppendLine(String.Format("GroupMask: {0}", GroupMask));
|
|
output.AppendLine(String.Format("EveryoneMask: {0}", EveryoneMask));
|
|
output.AppendLine(String.Format("NextOwnerMask: {0}", NextOwnerMask));
|
|
output.AppendLine(String.Format("OwnershipCost: {0}", OwnershipCost));
|
|
output.AppendLine(String.Format("SaleType: {0}", SaleType));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
output.AppendLine(String.Format("LastOwnerID: {0}", LastOwnerID));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Description, "Description");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectPropertiesFamily; } }
|
|
public ObjectDataBlock ObjectData;
|
|
|
|
public ObjectPropertiesFamilyPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 10;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
ObjectData = new ObjectDataBlock();
|
|
}
|
|
|
|
public ObjectPropertiesFamilyPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ObjectPropertiesFamilyPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ObjectData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += ObjectData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ObjectData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectPropertiesFamily ---" + Environment.NewLine;
|
|
output += ObjectData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelPropertiesRequestPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int SequenceID;
|
|
public float West;
|
|
public float South;
|
|
public float East;
|
|
public float North;
|
|
public bool SnapSelection;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 21;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
West = Utils.BytesToFloat(bytes, i); i += 4;
|
|
South = Utils.BytesToFloat(bytes, i); i += 4;
|
|
East = Utils.BytesToFloat(bytes, i); i += 4;
|
|
North = Utils.BytesToFloat(bytes, i); i += 4;
|
|
SnapSelection = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
Utils.FloatToBytes(West, bytes, i); i += 4;
|
|
Utils.FloatToBytes(South, bytes, i); i += 4;
|
|
Utils.FloatToBytes(East, bytes, i); i += 4;
|
|
Utils.FloatToBytes(North, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((SnapSelection) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
output.AppendLine(String.Format("West: {0}", West));
|
|
output.AppendLine(String.Format("South: {0}", South));
|
|
output.AppendLine(String.Format("East: {0}", East));
|
|
output.AppendLine(String.Format("North: {0}", North));
|
|
output.Append(String.Format("SnapSelection: {0}", SnapSelection));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelPropertiesRequest; } }
|
|
public AgentDataBlock AgentData;
|
|
public ParcelDataBlock ParcelData;
|
|
|
|
public ParcelPropertiesRequestPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 11;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
ParcelData = new ParcelDataBlock();
|
|
}
|
|
|
|
public ParcelPropertiesRequestPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelPropertiesRequestPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length; length += ParcelData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelPropertiesRequest ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AttachedSoundPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
public UUID SoundID;
|
|
public UUID ObjectID;
|
|
public UUID OwnerID;
|
|
public float Gain;
|
|
public byte Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 53;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SoundID.FromBytes(bytes, i); i += 16;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
Gain = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Flags = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SoundID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(Gain, bytes, i); i += 4;
|
|
bytes[i++] = Flags;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
output.AppendLine(String.Format("SoundID: {0}", SoundID));
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("Gain: {0}", Gain));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AttachedSound; } }
|
|
public DataBlockBlock DataBlock;
|
|
|
|
public AttachedSoundPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 13;
|
|
Header.Reliable = true;
|
|
DataBlock = new DataBlockBlock();
|
|
}
|
|
|
|
public AttachedSoundPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AttachedSoundPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += DataBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AttachedSound ---" + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AttachedSoundGainChangePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public float Gain;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
Gain = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(Gain, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.Append(String.Format("Gain: {0}", Gain));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AttachedSoundGainChange; } }
|
|
public DataBlockBlock DataBlock;
|
|
|
|
public AttachedSoundGainChangePacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 14;
|
|
Header.Reliable = true;
|
|
DataBlock = new DataBlockBlock();
|
|
}
|
|
|
|
public AttachedSoundGainChangePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AttachedSoundGainChangePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
DataBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += DataBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
DataBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AttachedSoundGainChange ---" + Environment.NewLine;
|
|
output += DataBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PreloadSoundPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class DataBlockBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
public UUID OwnerID;
|
|
public UUID SoundID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 48;
|
|
}
|
|
}
|
|
|
|
public DataBlockBlock() { }
|
|
public DataBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
SoundID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SoundID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataBlock --");
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.Append(String.Format("SoundID: {0}", SoundID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.PreloadSound; } }
|
|
public DataBlockBlock[] DataBlock;
|
|
|
|
public PreloadSoundPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 15;
|
|
Header.Reliable = true;
|
|
DataBlock = new DataBlockBlock[0];
|
|
}
|
|
|
|
public PreloadSoundPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(DataBlock.Length < count) {
|
|
DataBlock = new DataBlockBlock[count];
|
|
for(int j = 0; j < count; j++) DataBlock[j] = new DataBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ DataBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public PreloadSoundPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(DataBlock.Length < count) {
|
|
DataBlock = new DataBlockBlock[count];
|
|
for(int j = 0; j < count; j++) DataBlock[j] = new DataBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ DataBlock[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < DataBlock.Length; j++) { length += DataBlock[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)DataBlock.Length;
|
|
for (int j = 0; j < DataBlock.Length; j++) { DataBlock[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- PreloadSound ---" + Environment.NewLine;
|
|
for (int j = 0; j < DataBlock.Length; j++)
|
|
{
|
|
output += DataBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ViewerEffectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class EffectBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public UUID AgentID;
|
|
public byte Type;
|
|
public float Duration;
|
|
public byte[] Color;
|
|
private byte[] _typedata;
|
|
public byte[] TypeData
|
|
{
|
|
get { return _typedata; }
|
|
set
|
|
{
|
|
if (value == null) { _typedata = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _typedata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _typedata, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 41;
|
|
if (TypeData != null) { length += 1 + TypeData.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public EffectBlock() { }
|
|
public EffectBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
Type = (byte)bytes[i++];
|
|
Duration = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Color = new byte[4];
|
|
Buffer.BlockCopy(bytes, i, Color, 0, 4); i += 4;
|
|
length = (ushort)bytes[i++];
|
|
_typedata = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _typedata, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = Type;
|
|
Utils.FloatToBytes(Duration, bytes, i); i += 4;
|
|
Buffer.BlockCopy(Color, 0, bytes, i, 4);i += 4;
|
|
if(TypeData == null) { Console.WriteLine("Warning: TypeData is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TypeData.Length;
|
|
Buffer.BlockCopy(TypeData, 0, bytes, i, TypeData.Length); i += TypeData.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Effect --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("Type: {0}", Type));
|
|
output.AppendLine(String.Format("Duration: {0}", Duration));
|
|
Helpers.FieldToString(output, Color, "Color");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TypeData, "TypeData");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ViewerEffect; } }
|
|
public AgentDataBlock AgentData;
|
|
public EffectBlock[] Effect;
|
|
|
|
public ViewerEffectPacket()
|
|
{
|
|
Header = new MediumHeader();
|
|
Header.ID = 17;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
Effect = new EffectBlock[0];
|
|
}
|
|
|
|
public ViewerEffectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Effect.Length < count) {
|
|
Effect = new EffectBlock[count];
|
|
for(int j = 0; j < count; j++) Effect[j] = new EffectBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Effect[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ViewerEffectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(Effect.Length < count) {
|
|
Effect = new EffectBlock[count];
|
|
for(int j = 0; j < count; j++) Effect[j] = new EffectBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ Effect[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 8;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < Effect.Length; j++) { length += Effect[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)Effect.Length;
|
|
for (int j = 0; j < Effect.Length; j++) { Effect[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ViewerEffect ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < Effect.Length; j++)
|
|
{
|
|
output += Effect[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class StartPingCheckPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class PingIDBlock : PacketBlock
|
|
{
|
|
public byte PingID;
|
|
public uint OldestUnacked;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
public PingIDBlock() { }
|
|
public PingIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PingID = (byte)bytes[i++];
|
|
OldestUnacked = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = PingID;
|
|
Utils.UIntToBytes(OldestUnacked, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PingID --");
|
|
output.AppendLine(String.Format("PingID: {0}", PingID));
|
|
output.Append(String.Format("OldestUnacked: {0}", OldestUnacked));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.StartPingCheck; } }
|
|
public PingIDBlock PingID;
|
|
|
|
public StartPingCheckPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 1;
|
|
Header.Reliable = true;
|
|
PingID = new PingIDBlock();
|
|
}
|
|
|
|
public StartPingCheckPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
PingID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public StartPingCheckPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
PingID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += PingID.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
PingID.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- StartPingCheck ---" + Environment.NewLine;
|
|
output += PingID.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CompletePingCheckPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class PingIDBlock : PacketBlock
|
|
{
|
|
public byte PingID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public PingIDBlock() { }
|
|
public PingIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
PingID = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = PingID;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PingID --");
|
|
output.Append(String.Format("PingID: {0}", PingID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CompletePingCheck; } }
|
|
public PingIDBlock PingID;
|
|
|
|
public CompletePingCheckPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 2;
|
|
Header.Reliable = true;
|
|
PingID = new PingIDBlock();
|
|
}
|
|
|
|
public CompletePingCheckPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
PingID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CompletePingCheckPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
PingID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += PingID.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
PingID.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CompletePingCheck ---" + Environment.NewLine;
|
|
output += PingID.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public Quaternion BodyRotation;
|
|
public Quaternion HeadRotation;
|
|
public byte State;
|
|
public Vector3 CameraCenter;
|
|
public Vector3 CameraAtAxis;
|
|
public Vector3 CameraLeftAxis;
|
|
public Vector3 CameraUpAxis;
|
|
public float Far;
|
|
public uint ControlFlags;
|
|
public byte Flags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 114;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
BodyRotation.FromBytes(bytes, i, true); i += 12;
|
|
HeadRotation.FromBytes(bytes, i, true); i += 12;
|
|
State = (byte)bytes[i++];
|
|
CameraCenter.FromBytes(bytes, i); i += 12;
|
|
CameraAtAxis.FromBytes(bytes, i); i += 12;
|
|
CameraLeftAxis.FromBytes(bytes, i); i += 12;
|
|
CameraUpAxis.FromBytes(bytes, i); i += 12;
|
|
Far = Utils.BytesToFloat(bytes, i); i += 4;
|
|
ControlFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Flags = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(BodyRotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(HeadRotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = State;
|
|
Buffer.BlockCopy(CameraCenter.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(CameraAtAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(CameraLeftAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(CameraUpAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.FloatToBytes(Far, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ControlFlags, bytes, i); i += 4;
|
|
bytes[i++] = Flags;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("BodyRotation: {0}", BodyRotation));
|
|
output.AppendLine(String.Format("HeadRotation: {0}", HeadRotation));
|
|
output.AppendLine(String.Format("State: {0}", State));
|
|
output.AppendLine(String.Format("CameraCenter: {0}", CameraCenter));
|
|
output.AppendLine(String.Format("CameraAtAxis: {0}", CameraAtAxis));
|
|
output.AppendLine(String.Format("CameraLeftAxis: {0}", CameraLeftAxis));
|
|
output.AppendLine(String.Format("CameraUpAxis: {0}", CameraUpAxis));
|
|
output.AppendLine(String.Format("Far: {0}", Far));
|
|
output.AppendLine(String.Format("ControlFlags: {0}", ControlFlags));
|
|
output.Append(String.Format("Flags: {0}", Flags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentUpdatePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 4;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentAnimationPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AnimationListBlock : PacketBlock
|
|
{
|
|
public UUID AnimID;
|
|
public bool StartAnim;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 17;
|
|
}
|
|
}
|
|
|
|
public AnimationListBlock() { }
|
|
public AnimationListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AnimID.FromBytes(bytes, i); i += 16;
|
|
StartAnim = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AnimID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((StartAnim) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AnimationList --");
|
|
output.AppendLine(String.Format("AnimID: {0}", AnimID));
|
|
output.Append(String.Format("StartAnim: {0}", StartAnim));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PhysicalAvatarEventListBlock : PacketBlock
|
|
{
|
|
private byte[] _typedata;
|
|
public byte[] TypeData
|
|
{
|
|
get { return _typedata; }
|
|
set
|
|
{
|
|
if (value == null) { _typedata = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _typedata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _typedata, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (TypeData != null) { length += 1 + TypeData.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public PhysicalAvatarEventListBlock() { }
|
|
public PhysicalAvatarEventListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_typedata = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _typedata, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(TypeData == null) { Console.WriteLine("Warning: TypeData is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TypeData.Length;
|
|
Buffer.BlockCopy(TypeData, 0, bytes, i, TypeData.Length); i += TypeData.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PhysicalAvatarEventList --");
|
|
Helpers.FieldToString(output, TypeData, "TypeData");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentAnimation; } }
|
|
public AgentDataBlock AgentData;
|
|
public AnimationListBlock[] AnimationList;
|
|
public PhysicalAvatarEventListBlock[] PhysicalAvatarEventList;
|
|
|
|
public AgentAnimationPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 5;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
AnimationList = new AnimationListBlock[0];
|
|
PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[0];
|
|
}
|
|
|
|
public AgentAnimationPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(AnimationList.Length < count) {
|
|
AnimationList = new AnimationListBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationList[j] = new AnimationListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationList[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(PhysicalAvatarEventList.Length < count) {
|
|
PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
|
|
for(int j = 0; j < count; j++) PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ PhysicalAvatarEventList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AgentAnimationPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(AnimationList.Length < count) {
|
|
AnimationList = new AnimationListBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationList[j] = new AnimationListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationList[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(PhysicalAvatarEventList.Length < count) {
|
|
PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
|
|
for(int j = 0; j < count; j++) PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ PhysicalAvatarEventList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < AnimationList.Length; j++) { length += AnimationList[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { length += PhysicalAvatarEventList[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)AnimationList.Length;
|
|
for (int j = 0; j < AnimationList.Length; j++) { AnimationList[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)PhysicalAvatarEventList.Length;
|
|
for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { PhysicalAvatarEventList[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentAnimation ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < AnimationList.Length; j++)
|
|
{
|
|
output += AnimationList[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < PhysicalAvatarEventList.Length; j++)
|
|
{
|
|
output += PhysicalAvatarEventList[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentRequestSitPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TargetObjectBlock : PacketBlock
|
|
{
|
|
public UUID TargetID;
|
|
public Vector3 Offset;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 28;
|
|
}
|
|
}
|
|
|
|
public TargetObjectBlock() { }
|
|
public TargetObjectBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
TargetID.FromBytes(bytes, i); i += 16;
|
|
Offset.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TargetID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(Offset.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TargetObject --");
|
|
output.AppendLine(String.Format("TargetID: {0}", TargetID));
|
|
output.Append(String.Format("Offset: {0}", Offset));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentRequestSit; } }
|
|
public AgentDataBlock AgentData;
|
|
public TargetObjectBlock TargetObject;
|
|
|
|
public AgentRequestSitPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 6;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
TargetObject = new TargetObjectBlock();
|
|
}
|
|
|
|
public AgentRequestSitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TargetObject.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentRequestSitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
TargetObject.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length; length += TargetObject.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
TargetObject.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentRequestSit ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
output += TargetObject.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgentSitPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AgentSit; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public AgentSitPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 7;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public AgentSitPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AgentSitPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AgentSit ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestImagePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class RequestImageBlock : PacketBlock
|
|
{
|
|
public UUID Image;
|
|
public sbyte DiscardLevel;
|
|
public float DownloadPriority;
|
|
public uint Packet;
|
|
public byte Type;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 26;
|
|
}
|
|
}
|
|
|
|
public RequestImageBlock() { }
|
|
public RequestImageBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Image.FromBytes(bytes, i); i += 16;
|
|
DiscardLevel = (sbyte)bytes[i++];
|
|
DownloadPriority = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Packet = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Type = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Image.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)DiscardLevel;
|
|
Utils.FloatToBytes(DownloadPriority, bytes, i); i += 4;
|
|
Utils.UIntToBytes(Packet, bytes, i); i += 4;
|
|
bytes[i++] = Type;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RequestImage --");
|
|
output.AppendLine(String.Format("Image: {0}", Image));
|
|
output.AppendLine(String.Format("DiscardLevel: {0}", DiscardLevel));
|
|
output.AppendLine(String.Format("DownloadPriority: {0}", DownloadPriority));
|
|
output.AppendLine(String.Format("Packet: {0}", Packet));
|
|
output.Append(String.Format("Type: {0}", Type));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.RequestImage; } }
|
|
public AgentDataBlock AgentData;
|
|
public RequestImageBlock[] RequestImage;
|
|
|
|
public RequestImagePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 8;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
RequestImage = new RequestImageBlock[0];
|
|
}
|
|
|
|
public RequestImagePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RequestImage.Length < count) {
|
|
RequestImage = new RequestImageBlock[count];
|
|
for(int j = 0; j < count; j++) RequestImage[j] = new RequestImageBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RequestImage[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public RequestImagePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(RequestImage.Length < count) {
|
|
RequestImage = new RequestImageBlock[count];
|
|
for(int j = 0; j < count; j++) RequestImage[j] = new RequestImageBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ RequestImage[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < RequestImage.Length; j++) { length += RequestImage[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)RequestImage.Length;
|
|
for (int j = 0; j < RequestImage.Length; j++) { RequestImage[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- RequestImage ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < RequestImage.Length; j++)
|
|
{
|
|
output += RequestImage[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImageDataPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ImageIDBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public byte Codec;
|
|
public uint Size;
|
|
public ushort Packets;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 23;
|
|
}
|
|
}
|
|
|
|
public ImageIDBlock() { }
|
|
public ImageIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
Codec = (byte)bytes[i++];
|
|
Size = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Packets = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = Codec;
|
|
Utils.UIntToBytes(Size, bytes, i); i += 4;
|
|
bytes[i++] = (byte)(Packets % 256);
|
|
bytes[i++] = (byte)((Packets >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ImageID --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("Codec: {0}", Codec));
|
|
output.AppendLine(String.Format("Size: {0}", Size));
|
|
output.Append(String.Format("Packets: {0}", Packets));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImageDataBlock : PacketBlock
|
|
{
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ImageDataBlock() { }
|
|
public ImageDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ImageData --");
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ImageData; } }
|
|
public ImageIDBlock ImageID;
|
|
public ImageDataBlock ImageData;
|
|
|
|
public ImageDataPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 9;
|
|
Header.Reliable = true;
|
|
ImageID = new ImageIDBlock();
|
|
ImageData = new ImageDataBlock();
|
|
}
|
|
|
|
public ImageDataPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ImageID.FromBytes(bytes, ref i);
|
|
ImageData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ImageDataPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ImageID.FromBytes(bytes, ref i);
|
|
ImageData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += ImageID.Length; length += ImageData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ImageID.ToBytes(bytes, ref i);
|
|
ImageData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ImageData ---" + Environment.NewLine;
|
|
output += ImageID.ToString() + Environment.NewLine;
|
|
output += ImageData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImagePacketPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ImageIDBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
public ushort Packet;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 18;
|
|
}
|
|
}
|
|
|
|
public ImageIDBlock() { }
|
|
public ImageIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
Packet = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)(Packet % 256);
|
|
bytes[i++] = (byte)((Packet >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ImageID --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.Append(String.Format("Packet: {0}", Packet));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImageDataBlock : PacketBlock
|
|
{
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ImageDataBlock() { }
|
|
public ImageDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ImageData --");
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ImagePacket; } }
|
|
public ImageIDBlock ImageID;
|
|
public ImageDataBlock ImageData;
|
|
|
|
public ImagePacketPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 10;
|
|
Header.Reliable = true;
|
|
ImageID = new ImageIDBlock();
|
|
ImageData = new ImageDataBlock();
|
|
}
|
|
|
|
public ImagePacketPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ImageID.FromBytes(bytes, ref i);
|
|
ImageData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ImagePacketPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ImageID.FromBytes(bytes, ref i);
|
|
ImageData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += ImageID.Length; length += ImageData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ImageID.ToBytes(bytes, ref i);
|
|
ImageData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ImagePacket ---" + Environment.NewLine;
|
|
output += ImageID.ToString() + Environment.NewLine;
|
|
output += ImageData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LayerDataPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class LayerIDBlock : PacketBlock
|
|
{
|
|
public byte Type;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public LayerIDBlock() { }
|
|
public LayerIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Type = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = Type;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- LayerID --");
|
|
output.Append(String.Format("Type: {0}", Type));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class LayerDataBlock : PacketBlock
|
|
{
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public LayerDataBlock() { }
|
|
public LayerDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- LayerData --");
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.LayerData; } }
|
|
public LayerIDBlock LayerID;
|
|
public LayerDataBlock LayerData;
|
|
|
|
public LayerDataPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 11;
|
|
Header.Reliable = true;
|
|
LayerID = new LayerIDBlock();
|
|
LayerData = new LayerDataBlock();
|
|
}
|
|
|
|
public LayerDataPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
LayerID.FromBytes(bytes, ref i);
|
|
LayerData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public LayerDataPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
LayerID.FromBytes(bytes, ref i);
|
|
LayerData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += LayerID.Length; length += LayerData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
LayerID.ToBytes(bytes, ref i);
|
|
LayerData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- LayerData ---" + Environment.NewLine;
|
|
output += LayerID.ToString() + Environment.NewLine;
|
|
output += LayerData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public ushort TimeDilation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
public RegionDataBlock() { }
|
|
public RegionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
bytes[i++] = (byte)(TimeDilation % 256);
|
|
bytes[i++] = (byte)((TimeDilation >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.Append(String.Format("TimeDilation: {0}", TimeDilation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ID;
|
|
public byte State;
|
|
public UUID FullID;
|
|
public uint CRC;
|
|
public byte PCode;
|
|
public byte Material;
|
|
public byte ClickAction;
|
|
public Vector3 Scale;
|
|
private byte[] _objectdata;
|
|
public byte[] ObjectData
|
|
{
|
|
get { return _objectdata; }
|
|
set
|
|
{
|
|
if (value == null) { _objectdata = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _objectdata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _objectdata, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint ParentID;
|
|
public uint UpdateFlags;
|
|
public byte PathCurve;
|
|
public byte ProfileCurve;
|
|
public ushort PathBegin;
|
|
public ushort PathEnd;
|
|
public byte PathScaleX;
|
|
public byte PathScaleY;
|
|
public byte PathShearX;
|
|
public byte PathShearY;
|
|
public sbyte PathTwist;
|
|
public sbyte PathTwistBegin;
|
|
public sbyte PathRadiusOffset;
|
|
public sbyte PathTaperX;
|
|
public sbyte PathTaperY;
|
|
public byte PathRevolutions;
|
|
public sbyte PathSkew;
|
|
public ushort ProfileBegin;
|
|
public ushort ProfileEnd;
|
|
public ushort ProfileHollow;
|
|
private byte[] _textureentry;
|
|
public byte[] TextureEntry
|
|
{
|
|
get { return _textureentry; }
|
|
set
|
|
{
|
|
if (value == null) { _textureentry = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _textureanim;
|
|
public byte[] TextureAnim
|
|
{
|
|
get { return _textureanim; }
|
|
set
|
|
{
|
|
if (value == null) { _textureanim = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _textureanim = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureanim, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _namevalue;
|
|
public byte[] NameValue
|
|
{
|
|
get { return _namevalue; }
|
|
set
|
|
{
|
|
if (value == null) { _namevalue = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _namevalue = new byte[value.Length]; Buffer.BlockCopy(value, 0, _namevalue, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _text;
|
|
public byte[] Text
|
|
{
|
|
get { return _text; }
|
|
set
|
|
{
|
|
if (value == null) { _text = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _text = new byte[value.Length]; Buffer.BlockCopy(value, 0, _text, 0, value.Length); }
|
|
}
|
|
}
|
|
public byte[] TextColor;
|
|
private byte[] _mediaurl;
|
|
public byte[] MediaURL
|
|
{
|
|
get { return _mediaurl; }
|
|
set
|
|
{
|
|
if (value == null) { _mediaurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _psblock;
|
|
public byte[] PSBlock
|
|
{
|
|
get { return _psblock; }
|
|
set
|
|
{
|
|
if (value == null) { _psblock = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _psblock = new byte[value.Length]; Buffer.BlockCopy(value, 0, _psblock, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _extraparams;
|
|
public byte[] ExtraParams
|
|
{
|
|
get { return _extraparams; }
|
|
set
|
|
{
|
|
if (value == null) { _extraparams = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _extraparams = new byte[value.Length]; Buffer.BlockCopy(value, 0, _extraparams, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID Sound;
|
|
public UUID OwnerID;
|
|
public float Gain;
|
|
public byte Flags;
|
|
public float Radius;
|
|
public byte JointType;
|
|
public Vector3 JointPivot;
|
|
public Vector3 JointAxisOrAnchor;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 141;
|
|
if (ObjectData != null) { length += 1 + ObjectData.Length; }
|
|
if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
|
|
if (TextureAnim != null) { length += 1 + TextureAnim.Length; }
|
|
if (NameValue != null) { length += 2 + NameValue.Length; }
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
if (Text != null) { length += 1 + Text.Length; }
|
|
if (MediaURL != null) { length += 1 + MediaURL.Length; }
|
|
if (PSBlock != null) { length += 1 + PSBlock.Length; }
|
|
if (ExtraParams != null) { length += 1 + ExtraParams.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
State = (byte)bytes[i++];
|
|
FullID.FromBytes(bytes, i); i += 16;
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PCode = (byte)bytes[i++];
|
|
Material = (byte)bytes[i++];
|
|
ClickAction = (byte)bytes[i++];
|
|
Scale.FromBytes(bytes, i); i += 12;
|
|
length = (ushort)bytes[i++];
|
|
_objectdata = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _objectdata, 0, length); i += length;
|
|
ParentID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
UpdateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PathCurve = (byte)bytes[i++];
|
|
ProfileCurve = (byte)bytes[i++];
|
|
PathBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
PathEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
PathScaleX = (byte)bytes[i++];
|
|
PathScaleY = (byte)bytes[i++];
|
|
PathShearX = (byte)bytes[i++];
|
|
PathShearY = (byte)bytes[i++];
|
|
PathTwist = (sbyte)bytes[i++];
|
|
PathTwistBegin = (sbyte)bytes[i++];
|
|
PathRadiusOffset = (sbyte)bytes[i++];
|
|
PathTaperX = (sbyte)bytes[i++];
|
|
PathTaperY = (sbyte)bytes[i++];
|
|
PathRevolutions = (byte)bytes[i++];
|
|
PathSkew = (sbyte)bytes[i++];
|
|
ProfileBegin = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ProfileEnd = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
ProfileHollow = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_textureentry = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_textureanim = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureanim, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_namevalue = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _namevalue, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_text = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _text, 0, length); i += length;
|
|
TextColor = new byte[4];
|
|
Buffer.BlockCopy(bytes, i, TextColor, 0, 4); i += 4;
|
|
length = (ushort)bytes[i++];
|
|
_mediaurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_psblock = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _psblock, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_extraparams = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _extraparams, 0, length); i += length;
|
|
Sound.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
Gain = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Flags = (byte)bytes[i++];
|
|
Radius = Utils.BytesToFloat(bytes, i); i += 4;
|
|
JointType = (byte)bytes[i++];
|
|
JointPivot.FromBytes(bytes, i); i += 12;
|
|
JointAxisOrAnchor.FromBytes(bytes, i); i += 12;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ID, bytes, i); i += 4;
|
|
bytes[i++] = State;
|
|
Buffer.BlockCopy(FullID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
bytes[i++] = PCode;
|
|
bytes[i++] = Material;
|
|
bytes[i++] = ClickAction;
|
|
Buffer.BlockCopy(Scale.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
if(ObjectData == null) { Console.WriteLine("Warning: ObjectData is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
Buffer.BlockCopy(ObjectData, 0, bytes, i, ObjectData.Length); i += ObjectData.Length;
|
|
Utils.UIntToBytes(ParentID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(UpdateFlags, bytes, i); i += 4;
|
|
bytes[i++] = PathCurve;
|
|
bytes[i++] = ProfileCurve;
|
|
bytes[i++] = (byte)(PathBegin % 256);
|
|
bytes[i++] = (byte)((PathBegin >> 8) % 256);
|
|
bytes[i++] = (byte)(PathEnd % 256);
|
|
bytes[i++] = (byte)((PathEnd >> 8) % 256);
|
|
bytes[i++] = PathScaleX;
|
|
bytes[i++] = PathScaleY;
|
|
bytes[i++] = PathShearX;
|
|
bytes[i++] = PathShearY;
|
|
bytes[i++] = (byte)PathTwist;
|
|
bytes[i++] = (byte)PathTwistBegin;
|
|
bytes[i++] = (byte)PathRadiusOffset;
|
|
bytes[i++] = (byte)PathTaperX;
|
|
bytes[i++] = (byte)PathTaperY;
|
|
bytes[i++] = PathRevolutions;
|
|
bytes[i++] = (byte)PathSkew;
|
|
bytes[i++] = (byte)(ProfileBegin % 256);
|
|
bytes[i++] = (byte)((ProfileBegin >> 8) % 256);
|
|
bytes[i++] = (byte)(ProfileEnd % 256);
|
|
bytes[i++] = (byte)((ProfileEnd >> 8) % 256);
|
|
bytes[i++] = (byte)(ProfileHollow % 256);
|
|
bytes[i++] = (byte)((ProfileHollow >> 8) % 256);
|
|
if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(TextureEntry.Length % 256);
|
|
bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
|
|
Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
|
|
if(TextureAnim == null) { Console.WriteLine("Warning: TextureAnim is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TextureAnim.Length;
|
|
Buffer.BlockCopy(TextureAnim, 0, bytes, i, TextureAnim.Length); i += TextureAnim.Length;
|
|
if(NameValue == null) { Console.WriteLine("Warning: NameValue is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(NameValue.Length % 256);
|
|
bytes[i++] = (byte)((NameValue.Length >> 8) % 256);
|
|
Buffer.BlockCopy(NameValue, 0, bytes, i, NameValue.Length); i += NameValue.Length;
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
if(Text == null) { Console.WriteLine("Warning: Text is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Text.Length;
|
|
Buffer.BlockCopy(Text, 0, bytes, i, Text.Length); i += Text.Length;
|
|
Buffer.BlockCopy(TextColor, 0, bytes, i, 4);i += 4;
|
|
if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaURL.Length;
|
|
Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
|
|
if(PSBlock == null) { Console.WriteLine("Warning: PSBlock is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)PSBlock.Length;
|
|
Buffer.BlockCopy(PSBlock, 0, bytes, i, PSBlock.Length); i += PSBlock.Length;
|
|
if(ExtraParams == null) { Console.WriteLine("Warning: ExtraParams is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)ExtraParams.Length;
|
|
Buffer.BlockCopy(ExtraParams, 0, bytes, i, ExtraParams.Length); i += ExtraParams.Length;
|
|
Buffer.BlockCopy(Sound.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.FloatToBytes(Gain, bytes, i); i += 4;
|
|
bytes[i++] = Flags;
|
|
Utils.FloatToBytes(Radius, bytes, i); i += 4;
|
|
bytes[i++] = JointType;
|
|
Buffer.BlockCopy(JointPivot.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(JointAxisOrAnchor.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("State: {0}", State));
|
|
output.AppendLine(String.Format("FullID: {0}", FullID));
|
|
output.AppendLine(String.Format("CRC: {0}", CRC));
|
|
output.AppendLine(String.Format("PCode: {0}", PCode));
|
|
output.AppendLine(String.Format("Material: {0}", Material));
|
|
output.AppendLine(String.Format("ClickAction: {0}", ClickAction));
|
|
output.AppendLine(String.Format("Scale: {0}", Scale));
|
|
Helpers.FieldToString(output, ObjectData, "ObjectData");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("ParentID: {0}", ParentID));
|
|
output.AppendLine(String.Format("UpdateFlags: {0}", UpdateFlags));
|
|
output.AppendLine(String.Format("PathCurve: {0}", PathCurve));
|
|
output.AppendLine(String.Format("ProfileCurve: {0}", ProfileCurve));
|
|
output.AppendLine(String.Format("PathBegin: {0}", PathBegin));
|
|
output.AppendLine(String.Format("PathEnd: {0}", PathEnd));
|
|
output.AppendLine(String.Format("PathScaleX: {0}", PathScaleX));
|
|
output.AppendLine(String.Format("PathScaleY: {0}", PathScaleY));
|
|
output.AppendLine(String.Format("PathShearX: {0}", PathShearX));
|
|
output.AppendLine(String.Format("PathShearY: {0}", PathShearY));
|
|
output.AppendLine(String.Format("PathTwist: {0}", PathTwist));
|
|
output.AppendLine(String.Format("PathTwistBegin: {0}", PathTwistBegin));
|
|
output.AppendLine(String.Format("PathRadiusOffset: {0}", PathRadiusOffset));
|
|
output.AppendLine(String.Format("PathTaperX: {0}", PathTaperX));
|
|
output.AppendLine(String.Format("PathTaperY: {0}", PathTaperY));
|
|
output.AppendLine(String.Format("PathRevolutions: {0}", PathRevolutions));
|
|
output.AppendLine(String.Format("PathSkew: {0}", PathSkew));
|
|
output.AppendLine(String.Format("ProfileBegin: {0}", ProfileBegin));
|
|
output.AppendLine(String.Format("ProfileEnd: {0}", ProfileEnd));
|
|
output.AppendLine(String.Format("ProfileHollow: {0}", ProfileHollow));
|
|
Helpers.FieldToString(output, TextureEntry, "TextureEntry");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TextureAnim, "TextureAnim");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, NameValue, "NameValue");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Text, "Text");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TextColor, "TextColor");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, MediaURL, "MediaURL");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, PSBlock, "PSBlock");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, ExtraParams, "ExtraParams");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Sound: {0}", Sound));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("Gain: {0}", Gain));
|
|
output.AppendLine(String.Format("Flags: {0}", Flags));
|
|
output.AppendLine(String.Format("Radius: {0}", Radius));
|
|
output.AppendLine(String.Format("JointType: {0}", JointType));
|
|
output.AppendLine(String.Format("JointPivot: {0}", JointPivot));
|
|
output.Append(String.Format("JointAxisOrAnchor: {0}", JointAxisOrAnchor));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectUpdate; } }
|
|
public RegionDataBlock RegionData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectUpdatePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 12;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
RegionData = new RegionDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += RegionData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RegionData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectUpdate ---" + Environment.NewLine;
|
|
output += RegionData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectUpdateCompressedPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public ushort TimeDilation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
public RegionDataBlock() { }
|
|
public RegionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
bytes[i++] = (byte)(TimeDilation % 256);
|
|
bytes[i++] = (byte)((TimeDilation >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.Append(String.Format("TimeDilation: {0}", TimeDilation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint UpdateFlags;
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 4;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
UpdateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(UpdateFlags, bytes, i); i += 4;
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("UpdateFlags: {0}", UpdateFlags));
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectUpdateCompressed; } }
|
|
public RegionDataBlock RegionData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectUpdateCompressedPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 13;
|
|
Header.Reliable = true;
|
|
RegionData = new RegionDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectUpdateCompressedPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectUpdateCompressedPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += RegionData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RegionData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectUpdateCompressed ---" + Environment.NewLine;
|
|
output += RegionData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectUpdateCachedPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public ushort TimeDilation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
public RegionDataBlock() { }
|
|
public RegionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
bytes[i++] = (byte)(TimeDilation % 256);
|
|
bytes[i++] = (byte)((TimeDilation >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.Append(String.Format("TimeDilation: {0}", TimeDilation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ID;
|
|
public uint CRC;
|
|
public uint UpdateFlags;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
CRC = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
UpdateFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ID, bytes, i); i += 4;
|
|
Utils.UIntToBytes(CRC, bytes, i); i += 4;
|
|
Utils.UIntToBytes(UpdateFlags, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.AppendLine(String.Format("CRC: {0}", CRC));
|
|
output.Append(String.Format("UpdateFlags: {0}", UpdateFlags));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ObjectUpdateCached; } }
|
|
public RegionDataBlock RegionData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ObjectUpdateCachedPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 14;
|
|
Header.Reliable = true;
|
|
RegionData = new RegionDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ObjectUpdateCachedPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ObjectUpdateCachedPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += RegionData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RegionData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ObjectUpdateCached ---" + Environment.NewLine;
|
|
output += RegionData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ImprovedTerseObjectUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class RegionDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public ushort TimeDilation;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 10;
|
|
}
|
|
}
|
|
|
|
public RegionDataBlock() { }
|
|
public RegionDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
TimeDilation = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
bytes[i++] = (byte)(TimeDilation % 256);
|
|
bytes[i++] = (byte)((TimeDilation >> 8) % 256);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- RegionData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.Append(String.Format("TimeDilation: {0}", TimeDilation));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _textureentry;
|
|
public byte[] TextureEntry
|
|
{
|
|
get { return _textureentry; }
|
|
set
|
|
{
|
|
if (value == null) { _textureentry = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _textureentry = new byte[value.Length]; Buffer.BlockCopy(value, 0, _textureentry, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Data != null) { length += 1 + Data.Length; }
|
|
if (TextureEntry != null) { length += 2 + TextureEntry.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_textureentry = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _textureentry, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Data.Length;
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
if(TextureEntry == null) { Console.WriteLine("Warning: TextureEntry is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(TextureEntry.Length % 256);
|
|
bytes[i++] = (byte)((TextureEntry.Length >> 8) % 256);
|
|
Buffer.BlockCopy(TextureEntry, 0, bytes, i, TextureEntry.Length); i += TextureEntry.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, TextureEntry, "TextureEntry");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ImprovedTerseObjectUpdate; } }
|
|
public RegionDataBlock RegionData;
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public ImprovedTerseObjectUpdatePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 15;
|
|
Header.Reliable = true;
|
|
RegionData = new RegionDataBlock();
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public ImprovedTerseObjectUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ImprovedTerseObjectUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
RegionData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += RegionData.Length;;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
RegionData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ImprovedTerseObjectUpdate ---" + Environment.NewLine;
|
|
output += RegionData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class KillObjectPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ObjectDataBlock : PacketBlock
|
|
{
|
|
public uint ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
public ObjectDataBlock() { }
|
|
public ObjectDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UIntToBytes(ID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ObjectData --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.KillObject; } }
|
|
public ObjectDataBlock[] ObjectData;
|
|
|
|
public KillObjectPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 16;
|
|
Header.Reliable = true;
|
|
ObjectData = new ObjectDataBlock[0];
|
|
}
|
|
|
|
public KillObjectPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public KillObjectPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
int count = (int)bytes[i++];
|
|
if(ObjectData.Length < count) {
|
|
ObjectData = new ObjectDataBlock[count];
|
|
for(int j = 0; j < count; j++) ObjectData[j] = new ObjectDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ ObjectData[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
;
|
|
length++;
|
|
for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)ObjectData.Length;
|
|
for (int j = 0; j < ObjectData.Length; j++) { ObjectData[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- KillObject ---" + Environment.NewLine;
|
|
for (int j = 0; j < ObjectData.Length; j++)
|
|
{
|
|
output += ObjectData[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class TransferPacketPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class TransferDataBlock : PacketBlock
|
|
{
|
|
public UUID TransferID;
|
|
public int ChannelType;
|
|
public int Packet;
|
|
public int Status;
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 28;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public TransferDataBlock() { }
|
|
public TransferDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
TransferID.FromBytes(bytes, i); i += 16;
|
|
ChannelType = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Packet = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Status = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(TransferID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(ChannelType, bytes, i); i += 4;
|
|
Utils.IntToBytes(Packet, bytes, i); i += 4;
|
|
Utils.IntToBytes(Status, bytes, i); i += 4;
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- TransferData --");
|
|
output.AppendLine(String.Format("TransferID: {0}", TransferID));
|
|
output.AppendLine(String.Format("ChannelType: {0}", ChannelType));
|
|
output.AppendLine(String.Format("Packet: {0}", Packet));
|
|
output.AppendLine(String.Format("Status: {0}", Status));
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.TransferPacket; } }
|
|
public TransferDataBlock TransferData;
|
|
|
|
public TransferPacketPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 17;
|
|
Header.Reliable = true;
|
|
TransferData = new TransferDataBlock();
|
|
}
|
|
|
|
public TransferPacketPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public TransferPacketPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
TransferData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += TransferData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
TransferData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- TransferPacket ---" + Environment.NewLine;
|
|
output += TransferData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SendXferPacketPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class XferIDBlock : PacketBlock
|
|
{
|
|
public ulong ID;
|
|
public uint Packet;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public XferIDBlock() { }
|
|
public XferIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Packet = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(ID, bytes, i); i += 8;
|
|
Utils.UIntToBytes(Packet, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- XferID --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.Append(String.Format("Packet: {0}", Packet));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class DataPacketBlock : PacketBlock
|
|
{
|
|
private byte[] _data;
|
|
public byte[] Data
|
|
{
|
|
get { return _data; }
|
|
set
|
|
{
|
|
if (value == null) { _data = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _data = new byte[value.Length]; Buffer.BlockCopy(value, 0, _data, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (Data != null) { length += 2 + Data.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public DataPacketBlock() { }
|
|
public DataPacketBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_data = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _data, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(Data == null) { Console.WriteLine("Warning: Data is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Data.Length % 256);
|
|
bytes[i++] = (byte)((Data.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Data, 0, bytes, i, Data.Length); i += Data.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- DataPacket --");
|
|
Helpers.FieldToString(output, Data, "Data");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SendXferPacket; } }
|
|
public XferIDBlock XferID;
|
|
public DataPacketBlock DataPacket;
|
|
|
|
public SendXferPacketPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 18;
|
|
Header.Reliable = true;
|
|
XferID = new XferIDBlock();
|
|
DataPacket = new DataPacketBlock();
|
|
}
|
|
|
|
public SendXferPacketPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
DataPacket.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SendXferPacketPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
DataPacket.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += XferID.Length; length += DataPacket.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
XferID.ToBytes(bytes, ref i);
|
|
DataPacket.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SendXferPacket ---" + Environment.NewLine;
|
|
output += XferID.ToString() + Environment.NewLine;
|
|
output += DataPacket.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ConfirmXferPacketPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class XferIDBlock : PacketBlock
|
|
{
|
|
public ulong ID;
|
|
public uint Packet;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 12;
|
|
}
|
|
}
|
|
|
|
public XferIDBlock() { }
|
|
public XferIDBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Packet = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(ID, bytes, i); i += 8;
|
|
Utils.UIntToBytes(Packet, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- XferID --");
|
|
output.AppendLine(String.Format("ID: {0}", ID));
|
|
output.Append(String.Format("Packet: {0}", Packet));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ConfirmXferPacket; } }
|
|
public XferIDBlock XferID;
|
|
|
|
public ConfirmXferPacketPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 19;
|
|
Header.Reliable = true;
|
|
XferID = new XferIDBlock();
|
|
}
|
|
|
|
public ConfirmXferPacketPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ConfirmXferPacketPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
XferID.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += XferID.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
XferID.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ConfirmXferPacket ---" + Environment.NewLine;
|
|
output += XferID.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarAnimationPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class SenderBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public SenderBlock() { }
|
|
public SenderBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- Sender --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AnimationListBlock : PacketBlock
|
|
{
|
|
public UUID AnimID;
|
|
public int AnimSequenceID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 20;
|
|
}
|
|
}
|
|
|
|
public AnimationListBlock() { }
|
|
public AnimationListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AnimID.FromBytes(bytes, i); i += 16;
|
|
AnimSequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(AnimID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(AnimSequenceID, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AnimationList --");
|
|
output.AppendLine(String.Format("AnimID: {0}", AnimID));
|
|
output.Append(String.Format("AnimSequenceID: {0}", AnimSequenceID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AnimationSourceListBlock : PacketBlock
|
|
{
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public AnimationSourceListBlock() { }
|
|
public AnimationSourceListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AnimationSourceList --");
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class PhysicalAvatarEventListBlock : PacketBlock
|
|
{
|
|
private byte[] _typedata;
|
|
public byte[] TypeData
|
|
{
|
|
get { return _typedata; }
|
|
set
|
|
{
|
|
if (value == null) { _typedata = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _typedata = new byte[value.Length]; Buffer.BlockCopy(value, 0, _typedata, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (TypeData != null) { length += 1 + TypeData.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public PhysicalAvatarEventListBlock() { }
|
|
public PhysicalAvatarEventListBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)bytes[i++];
|
|
_typedata = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _typedata, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(TypeData == null) { Console.WriteLine("Warning: TypeData is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)TypeData.Length;
|
|
Buffer.BlockCopy(TypeData, 0, bytes, i, TypeData.Length); i += TypeData.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- PhysicalAvatarEventList --");
|
|
Helpers.FieldToString(output, TypeData, "TypeData");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarAnimation; } }
|
|
public SenderBlock Sender;
|
|
public AnimationListBlock[] AnimationList;
|
|
public AnimationSourceListBlock[] AnimationSourceList;
|
|
public PhysicalAvatarEventListBlock[] PhysicalAvatarEventList;
|
|
|
|
public AvatarAnimationPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 20;
|
|
Header.Reliable = true;
|
|
Sender = new SenderBlock();
|
|
AnimationList = new AnimationListBlock[0];
|
|
AnimationSourceList = new AnimationSourceListBlock[0];
|
|
PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[0];
|
|
}
|
|
|
|
public AvatarAnimationPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Sender.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(AnimationList.Length < count) {
|
|
AnimationList = new AnimationListBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationList[j] = new AnimationListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationList[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(AnimationSourceList.Length < count) {
|
|
AnimationSourceList = new AnimationSourceListBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationSourceList[j] = new AnimationSourceListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationSourceList[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(PhysicalAvatarEventList.Length < count) {
|
|
PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
|
|
for(int j = 0; j < count; j++) PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ PhysicalAvatarEventList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public AvatarAnimationPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
Sender.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(AnimationList.Length < count) {
|
|
AnimationList = new AnimationListBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationList[j] = new AnimationListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationList[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(AnimationSourceList.Length < count) {
|
|
AnimationSourceList = new AnimationSourceListBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationSourceList[j] = new AnimationSourceListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationSourceList[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(PhysicalAvatarEventList.Length < count) {
|
|
PhysicalAvatarEventList = new PhysicalAvatarEventListBlock[count];
|
|
for(int j = 0; j < count; j++) PhysicalAvatarEventList[j] = new PhysicalAvatarEventListBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ PhysicalAvatarEventList[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += Sender.Length;;
|
|
length++;
|
|
for (int j = 0; j < AnimationList.Length; j++) { length += AnimationList[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < AnimationSourceList.Length; j++) { length += AnimationSourceList[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { length += PhysicalAvatarEventList[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
Sender.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)AnimationList.Length;
|
|
for (int j = 0; j < AnimationList.Length; j++) { AnimationList[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)AnimationSourceList.Length;
|
|
for (int j = 0; j < AnimationSourceList.Length; j++) { AnimationSourceList[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)PhysicalAvatarEventList.Length;
|
|
for (int j = 0; j < PhysicalAvatarEventList.Length; j++) { PhysicalAvatarEventList[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarAnimation ---" + Environment.NewLine;
|
|
output += Sender.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < AnimationList.Length; j++)
|
|
{
|
|
output += AnimationList[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < AnimationSourceList.Length; j++)
|
|
{
|
|
output += AnimationSourceList[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < PhysicalAvatarEventList.Length; j++)
|
|
{
|
|
output += PhysicalAvatarEventList[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AvatarSitResponsePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class SitObjectBlock : PacketBlock
|
|
{
|
|
public UUID ID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public SitObjectBlock() { }
|
|
public SitObjectBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(ID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SitObject --");
|
|
output.Append(String.Format("ID: {0}", ID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SitTransformBlock : PacketBlock
|
|
{
|
|
public bool AutoPilot;
|
|
public Vector3 SitPosition;
|
|
public Quaternion SitRotation;
|
|
public Vector3 CameraEyeOffset;
|
|
public Vector3 CameraAtOffset;
|
|
public bool ForceMouselook;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 50;
|
|
}
|
|
}
|
|
|
|
public SitTransformBlock() { }
|
|
public SitTransformBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
AutoPilot = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
SitPosition.FromBytes(bytes, i); i += 12;
|
|
SitRotation.FromBytes(bytes, i, true); i += 12;
|
|
CameraEyeOffset.FromBytes(bytes, i); i += 12;
|
|
CameraAtOffset.FromBytes(bytes, i); i += 12;
|
|
ForceMouselook = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((AutoPilot) ? 1 : 0);
|
|
Buffer.BlockCopy(SitPosition.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(SitRotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(CameraEyeOffset.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(CameraAtOffset.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = (byte)((ForceMouselook) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SitTransform --");
|
|
output.AppendLine(String.Format("AutoPilot: {0}", AutoPilot));
|
|
output.AppendLine(String.Format("SitPosition: {0}", SitPosition));
|
|
output.AppendLine(String.Format("SitRotation: {0}", SitRotation));
|
|
output.AppendLine(String.Format("CameraEyeOffset: {0}", CameraEyeOffset));
|
|
output.AppendLine(String.Format("CameraAtOffset: {0}", CameraAtOffset));
|
|
output.Append(String.Format("ForceMouselook: {0}", ForceMouselook));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.AvatarSitResponse; } }
|
|
public SitObjectBlock SitObject;
|
|
public SitTransformBlock SitTransform;
|
|
|
|
public AvatarSitResponsePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 21;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
SitObject = new SitObjectBlock();
|
|
SitTransform = new SitTransformBlock();
|
|
}
|
|
|
|
public AvatarSitResponsePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
SitObject.FromBytes(bytes, ref i);
|
|
SitTransform.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public AvatarSitResponsePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
SitObject.FromBytes(bytes, ref i);
|
|
SitTransform.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += SitObject.Length; length += SitTransform.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
SitObject.ToBytes(bytes, ref i);
|
|
SitTransform.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- AvatarSitResponse ---" + Environment.NewLine;
|
|
output += SitObject.ToString() + Environment.NewLine;
|
|
output += SitTransform.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class CameraConstraintPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class CameraCollidePlaneBlock : PacketBlock
|
|
{
|
|
public Vector4 Plane;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public CameraCollidePlaneBlock() { }
|
|
public CameraCollidePlaneBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Plane.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Plane.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- CameraCollidePlane --");
|
|
output.Append(String.Format("Plane: {0}", Plane));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.CameraConstraint; } }
|
|
public CameraCollidePlaneBlock CameraCollidePlane;
|
|
|
|
public CameraConstraintPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 22;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
CameraCollidePlane = new CameraCollidePlaneBlock();
|
|
}
|
|
|
|
public CameraConstraintPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CameraCollidePlane.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public CameraConstraintPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
CameraCollidePlane.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += CameraCollidePlane.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
CameraCollidePlane.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- CameraConstraint ---" + Environment.NewLine;
|
|
output += CameraCollidePlane.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ParcelPropertiesPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class ParcelDataBlock : PacketBlock
|
|
{
|
|
public int RequestResult;
|
|
public int SequenceID;
|
|
public bool SnapSelection;
|
|
public int SelfCount;
|
|
public int OtherCount;
|
|
public int PublicCount;
|
|
public int LocalID;
|
|
public UUID OwnerID;
|
|
public bool IsGroupOwned;
|
|
public uint AuctionID;
|
|
public int ClaimDate;
|
|
public int ClaimPrice;
|
|
public int RentPrice;
|
|
public Vector3 AABBMin;
|
|
public Vector3 AABBMax;
|
|
private byte[] _bitmap;
|
|
public byte[] Bitmap
|
|
{
|
|
get { return _bitmap; }
|
|
set
|
|
{
|
|
if (value == null) { _bitmap = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _bitmap = new byte[value.Length]; Buffer.BlockCopy(value, 0, _bitmap, 0, value.Length); }
|
|
}
|
|
}
|
|
public int Area;
|
|
public byte Status;
|
|
public int SimWideMaxPrims;
|
|
public int SimWideTotalPrims;
|
|
public int MaxPrims;
|
|
public int TotalPrims;
|
|
public int OwnerPrims;
|
|
public int GroupPrims;
|
|
public int OtherPrims;
|
|
public int SelectedPrims;
|
|
public float ParcelPrimBonus;
|
|
public int OtherCleanTime;
|
|
public uint ParcelFlags;
|
|
public int SalePrice;
|
|
private byte[] _name;
|
|
public byte[] Name
|
|
{
|
|
get { return _name; }
|
|
set
|
|
{
|
|
if (value == null) { _name = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _name = new byte[value.Length]; Buffer.BlockCopy(value, 0, _name, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _desc;
|
|
public byte[] Desc
|
|
{
|
|
get { return _desc; }
|
|
set
|
|
{
|
|
if (value == null) { _desc = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _desc = new byte[value.Length]; Buffer.BlockCopy(value, 0, _desc, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _musicurl;
|
|
public byte[] MusicURL
|
|
{
|
|
get { return _musicurl; }
|
|
set
|
|
{
|
|
if (value == null) { _musicurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _musicurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _musicurl, 0, value.Length); }
|
|
}
|
|
}
|
|
private byte[] _mediaurl;
|
|
public byte[] MediaURL
|
|
{
|
|
get { return _mediaurl; }
|
|
set
|
|
{
|
|
if (value == null) { _mediaurl = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _mediaurl = new byte[value.Length]; Buffer.BlockCopy(value, 0, _mediaurl, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID MediaID;
|
|
public byte MediaAutoScale;
|
|
public UUID GroupID;
|
|
public int PassPrice;
|
|
public float PassHours;
|
|
public byte Category;
|
|
public UUID AuthBuyerID;
|
|
public UUID SnapshotID;
|
|
public Vector3 UserLocation;
|
|
public Vector3 UserLookAt;
|
|
public byte LandingType;
|
|
public bool RegionPushOverride;
|
|
public bool RegionDenyAnonymous;
|
|
public bool RegionDenyIdentified;
|
|
public bool RegionDenyTransacted;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 238;
|
|
if (Bitmap != null) { length += 2 + Bitmap.Length; }
|
|
if (Name != null) { length += 1 + Name.Length; }
|
|
if (Desc != null) { length += 1 + Desc.Length; }
|
|
if (MusicURL != null) { length += 1 + MusicURL.Length; }
|
|
if (MediaURL != null) { length += 1 + MediaURL.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public ParcelDataBlock() { }
|
|
public ParcelDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RequestResult = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SequenceID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SnapSelection = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
SelfCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OtherCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PublicCount = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
LocalID = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
IsGroupOwned = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
AuctionID = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ClaimDate = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ClaimPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
RentPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AABBMin.FromBytes(bytes, i); i += 12;
|
|
AABBMax.FromBytes(bytes, i); i += 12;
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_bitmap = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _bitmap, 0, length); i += length;
|
|
Area = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
Status = (byte)bytes[i++];
|
|
SimWideMaxPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SimWideTotalPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
MaxPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
TotalPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OwnerPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
GroupPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
OtherPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SelectedPrims = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelPrimBonus = Utils.BytesToFloat(bytes, i); i += 4;
|
|
OtherCleanTime = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
ParcelFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
SalePrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
length = (ushort)bytes[i++];
|
|
_name = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _name, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_desc = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _desc, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_musicurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _musicurl, 0, length); i += length;
|
|
length = (ushort)bytes[i++];
|
|
_mediaurl = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _mediaurl, 0, length); i += length;
|
|
MediaID.FromBytes(bytes, i); i += 16;
|
|
MediaAutoScale = (byte)bytes[i++];
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
PassPrice = (int)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
PassHours = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Category = (byte)bytes[i++];
|
|
AuthBuyerID.FromBytes(bytes, i); i += 16;
|
|
SnapshotID.FromBytes(bytes, i); i += 16;
|
|
UserLocation.FromBytes(bytes, i); i += 12;
|
|
UserLookAt.FromBytes(bytes, i); i += 12;
|
|
LandingType = (byte)bytes[i++];
|
|
RegionPushOverride = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RegionDenyAnonymous = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RegionDenyIdentified = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
RegionDenyTransacted = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.IntToBytes(RequestResult, bytes, i); i += 4;
|
|
Utils.IntToBytes(SequenceID, bytes, i); i += 4;
|
|
bytes[i++] = (byte)((SnapSelection) ? 1 : 0);
|
|
Utils.IntToBytes(SelfCount, bytes, i); i += 4;
|
|
Utils.IntToBytes(OtherCount, bytes, i); i += 4;
|
|
Utils.IntToBytes(PublicCount, bytes, i); i += 4;
|
|
Utils.IntToBytes(LocalID, bytes, i); i += 4;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = (byte)((IsGroupOwned) ? 1 : 0);
|
|
Utils.UIntToBytes(AuctionID, bytes, i); i += 4;
|
|
Utils.IntToBytes(ClaimDate, bytes, i); i += 4;
|
|
Utils.IntToBytes(ClaimPrice, bytes, i); i += 4;
|
|
Utils.IntToBytes(RentPrice, bytes, i); i += 4;
|
|
Buffer.BlockCopy(AABBMin.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(AABBMax.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
if(Bitmap == null) { Console.WriteLine("Warning: Bitmap is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(Bitmap.Length % 256);
|
|
bytes[i++] = (byte)((Bitmap.Length >> 8) % 256);
|
|
Buffer.BlockCopy(Bitmap, 0, bytes, i, Bitmap.Length); i += Bitmap.Length;
|
|
Utils.IntToBytes(Area, bytes, i); i += 4;
|
|
bytes[i++] = Status;
|
|
Utils.IntToBytes(SimWideMaxPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(SimWideTotalPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(MaxPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(TotalPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(OwnerPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(GroupPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(OtherPrims, bytes, i); i += 4;
|
|
Utils.IntToBytes(SelectedPrims, bytes, i); i += 4;
|
|
Utils.FloatToBytes(ParcelPrimBonus, bytes, i); i += 4;
|
|
Utils.IntToBytes(OtherCleanTime, bytes, i); i += 4;
|
|
Utils.UIntToBytes(ParcelFlags, bytes, i); i += 4;
|
|
Utils.IntToBytes(SalePrice, bytes, i); i += 4;
|
|
if(Name == null) { Console.WriteLine("Warning: Name is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Name.Length;
|
|
Buffer.BlockCopy(Name, 0, bytes, i, Name.Length); i += Name.Length;
|
|
if(Desc == null) { Console.WriteLine("Warning: Desc is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Desc.Length;
|
|
Buffer.BlockCopy(Desc, 0, bytes, i, Desc.Length); i += Desc.Length;
|
|
if(MusicURL == null) { Console.WriteLine("Warning: MusicURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MusicURL.Length;
|
|
Buffer.BlockCopy(MusicURL, 0, bytes, i, MusicURL.Length); i += MusicURL.Length;
|
|
if(MediaURL == null) { Console.WriteLine("Warning: MediaURL is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)MediaURL.Length;
|
|
Buffer.BlockCopy(MediaURL, 0, bytes, i, MediaURL.Length); i += MediaURL.Length;
|
|
Buffer.BlockCopy(MediaID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = MediaAutoScale;
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.IntToBytes(PassPrice, bytes, i); i += 4;
|
|
Utils.FloatToBytes(PassHours, bytes, i); i += 4;
|
|
bytes[i++] = Category;
|
|
Buffer.BlockCopy(AuthBuyerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SnapshotID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(UserLocation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(UserLookAt.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = LandingType;
|
|
bytes[i++] = (byte)((RegionPushOverride) ? 1 : 0);
|
|
bytes[i++] = (byte)((RegionDenyAnonymous) ? 1 : 0);
|
|
bytes[i++] = (byte)((RegionDenyIdentified) ? 1 : 0);
|
|
bytes[i++] = (byte)((RegionDenyTransacted) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- ParcelData --");
|
|
output.AppendLine(String.Format("RequestResult: {0}", RequestResult));
|
|
output.AppendLine(String.Format("SequenceID: {0}", SequenceID));
|
|
output.AppendLine(String.Format("SnapSelection: {0}", SnapSelection));
|
|
output.AppendLine(String.Format("SelfCount: {0}", SelfCount));
|
|
output.AppendLine(String.Format("OtherCount: {0}", OtherCount));
|
|
output.AppendLine(String.Format("PublicCount: {0}", PublicCount));
|
|
output.AppendLine(String.Format("LocalID: {0}", LocalID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("IsGroupOwned: {0}", IsGroupOwned));
|
|
output.AppendLine(String.Format("AuctionID: {0}", AuctionID));
|
|
output.AppendLine(String.Format("ClaimDate: {0}", ClaimDate));
|
|
output.AppendLine(String.Format("ClaimPrice: {0}", ClaimPrice));
|
|
output.AppendLine(String.Format("RentPrice: {0}", RentPrice));
|
|
output.AppendLine(String.Format("AABBMin: {0}", AABBMin));
|
|
output.AppendLine(String.Format("AABBMax: {0}", AABBMax));
|
|
Helpers.FieldToString(output, Bitmap, "Bitmap");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("Area: {0}", Area));
|
|
output.AppendLine(String.Format("Status: {0}", Status));
|
|
output.AppendLine(String.Format("SimWideMaxPrims: {0}", SimWideMaxPrims));
|
|
output.AppendLine(String.Format("SimWideTotalPrims: {0}", SimWideTotalPrims));
|
|
output.AppendLine(String.Format("MaxPrims: {0}", MaxPrims));
|
|
output.AppendLine(String.Format("TotalPrims: {0}", TotalPrims));
|
|
output.AppendLine(String.Format("OwnerPrims: {0}", OwnerPrims));
|
|
output.AppendLine(String.Format("GroupPrims: {0}", GroupPrims));
|
|
output.AppendLine(String.Format("OtherPrims: {0}", OtherPrims));
|
|
output.AppendLine(String.Format("SelectedPrims: {0}", SelectedPrims));
|
|
output.AppendLine(String.Format("ParcelPrimBonus: {0}", ParcelPrimBonus));
|
|
output.AppendLine(String.Format("OtherCleanTime: {0}", OtherCleanTime));
|
|
output.AppendLine(String.Format("ParcelFlags: {0}", ParcelFlags));
|
|
output.AppendLine(String.Format("SalePrice: {0}", SalePrice));
|
|
Helpers.FieldToString(output, Name, "Name");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, Desc, "Desc");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, MusicURL, "MusicURL");
|
|
output.Append(Environment.NewLine);
|
|
Helpers.FieldToString(output, MediaURL, "MediaURL");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("MediaID: {0}", MediaID));
|
|
output.AppendLine(String.Format("MediaAutoScale: {0}", MediaAutoScale));
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("PassPrice: {0}", PassPrice));
|
|
output.AppendLine(String.Format("PassHours: {0}", PassHours));
|
|
output.AppendLine(String.Format("Category: {0}", Category));
|
|
output.AppendLine(String.Format("AuthBuyerID: {0}", AuthBuyerID));
|
|
output.AppendLine(String.Format("SnapshotID: {0}", SnapshotID));
|
|
output.AppendLine(String.Format("UserLocation: {0}", UserLocation));
|
|
output.AppendLine(String.Format("UserLookAt: {0}", UserLookAt));
|
|
output.AppendLine(String.Format("LandingType: {0}", LandingType));
|
|
output.AppendLine(String.Format("RegionPushOverride: {0}", RegionPushOverride));
|
|
output.AppendLine(String.Format("RegionDenyAnonymous: {0}", RegionDenyAnonymous));
|
|
output.AppendLine(String.Format("RegionDenyIdentified: {0}", RegionDenyIdentified));
|
|
output.Append(String.Format("RegionDenyTransacted: {0}", RegionDenyTransacted));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AgeVerificationBlockBlock : PacketBlock
|
|
{
|
|
public bool RegionDenyAgeUnverified;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public AgeVerificationBlockBlock() { }
|
|
public AgeVerificationBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionDenyAgeUnverified = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = (byte)((RegionDenyAgeUnverified) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgeVerificationBlock --");
|
|
output.Append(String.Format("RegionDenyAgeUnverified: {0}", RegionDenyAgeUnverified));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ParcelProperties; } }
|
|
public ParcelDataBlock ParcelData;
|
|
public AgeVerificationBlockBlock AgeVerificationBlock;
|
|
|
|
public ParcelPropertiesPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 23;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
ParcelData = new ParcelDataBlock();
|
|
AgeVerificationBlock = new AgeVerificationBlockBlock();
|
|
}
|
|
|
|
public ParcelPropertiesPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
AgeVerificationBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ParcelPropertiesPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
ParcelData.FromBytes(bytes, ref i);
|
|
AgeVerificationBlock.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += ParcelData.Length; length += AgeVerificationBlock.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
ParcelData.ToBytes(bytes, ref i);
|
|
AgeVerificationBlock.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ParcelProperties ---" + Environment.NewLine;
|
|
output += ParcelData.ToString() + Environment.NewLine;
|
|
output += AgeVerificationBlock.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChildAgentUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public uint ViewerCircuitCode;
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public Vector3 AgentPos;
|
|
public Vector3 AgentVel;
|
|
public Vector3 Center;
|
|
public Vector3 Size;
|
|
public Vector3 AtAxis;
|
|
public Vector3 LeftAxis;
|
|
public Vector3 UpAxis;
|
|
public bool ChangedGrid;
|
|
public float Far;
|
|
public float Aspect;
|
|
private byte[] _throttles;
|
|
public byte[] Throttles
|
|
{
|
|
get { return _throttles; }
|
|
set
|
|
{
|
|
if (value == null) { _throttles = null; return; }
|
|
if (value.Length > 255) { throw new OverflowException("Value exceeds 255 characters"); }
|
|
else { _throttles = new byte[value.Length]; Buffer.BlockCopy(value, 0, _throttles, 0, value.Length); }
|
|
}
|
|
}
|
|
public uint LocomotionState;
|
|
public Quaternion HeadRotation;
|
|
public Quaternion BodyRotation;
|
|
public uint ControlFlags;
|
|
public float EnergyLevel;
|
|
public byte GodLevel;
|
|
public bool AlwaysRun;
|
|
public UUID PreyAgent;
|
|
public byte AgentAccess;
|
|
private byte[] _agenttextures;
|
|
public byte[] AgentTextures
|
|
{
|
|
get { return _agenttextures; }
|
|
set
|
|
{
|
|
if (value == null) { _agenttextures = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _agenttextures = new byte[value.Length]; Buffer.BlockCopy(value, 0, _agenttextures, 0, value.Length); }
|
|
}
|
|
}
|
|
public UUID ActiveGroupID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 208;
|
|
if (Throttles != null) { length += 1 + Throttles.Length; }
|
|
if (AgentTextures != null) { length += 2 + AgentTextures.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
AgentPos.FromBytes(bytes, i); i += 12;
|
|
AgentVel.FromBytes(bytes, i); i += 12;
|
|
Center.FromBytes(bytes, i); i += 12;
|
|
Size.FromBytes(bytes, i); i += 12;
|
|
AtAxis.FromBytes(bytes, i); i += 12;
|
|
LeftAxis.FromBytes(bytes, i); i += 12;
|
|
UpAxis.FromBytes(bytes, i); i += 12;
|
|
ChangedGrid = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
Far = Utils.BytesToFloat(bytes, i); i += 4;
|
|
Aspect = Utils.BytesToFloat(bytes, i); i += 4;
|
|
length = (ushort)bytes[i++];
|
|
_throttles = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _throttles, 0, length); i += length;
|
|
LocomotionState = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
HeadRotation.FromBytes(bytes, i, true); i += 12;
|
|
BodyRotation.FromBytes(bytes, i, true); i += 12;
|
|
ControlFlags = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
EnergyLevel = Utils.BytesToFloat(bytes, i); i += 4;
|
|
GodLevel = (byte)bytes[i++];
|
|
AlwaysRun = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
PreyAgent.FromBytes(bytes, i); i += 16;
|
|
AgentAccess = (byte)bytes[i++];
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_agenttextures = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _agenttextures, 0, length); i += length;
|
|
ActiveGroupID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
Utils.UIntToBytes(ViewerCircuitCode, bytes, i); i += 4;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AgentPos.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(AgentVel.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Center.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Size.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(AtAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LeftAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(UpAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = (byte)((ChangedGrid) ? 1 : 0);
|
|
Utils.FloatToBytes(Far, bytes, i); i += 4;
|
|
Utils.FloatToBytes(Aspect, bytes, i); i += 4;
|
|
if(Throttles == null) { Console.WriteLine("Warning: Throttles is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)Throttles.Length;
|
|
Buffer.BlockCopy(Throttles, 0, bytes, i, Throttles.Length); i += Throttles.Length;
|
|
Utils.UIntToBytes(LocomotionState, bytes, i); i += 4;
|
|
Buffer.BlockCopy(HeadRotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(BodyRotation.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.UIntToBytes(ControlFlags, bytes, i); i += 4;
|
|
Utils.FloatToBytes(EnergyLevel, bytes, i); i += 4;
|
|
bytes[i++] = GodLevel;
|
|
bytes[i++] = (byte)((AlwaysRun) ? 1 : 0);
|
|
Buffer.BlockCopy(PreyAgent.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
bytes[i++] = AgentAccess;
|
|
if(AgentTextures == null) { Console.WriteLine("Warning: AgentTextures is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(AgentTextures.Length % 256);
|
|
bytes[i++] = (byte)((AgentTextures.Length >> 8) % 256);
|
|
Buffer.BlockCopy(AgentTextures, 0, bytes, i, AgentTextures.Length); i += AgentTextures.Length;
|
|
Buffer.BlockCopy(ActiveGroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.AppendLine(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("AgentPos: {0}", AgentPos));
|
|
output.AppendLine(String.Format("AgentVel: {0}", AgentVel));
|
|
output.AppendLine(String.Format("Center: {0}", Center));
|
|
output.AppendLine(String.Format("Size: {0}", Size));
|
|
output.AppendLine(String.Format("AtAxis: {0}", AtAxis));
|
|
output.AppendLine(String.Format("LeftAxis: {0}", LeftAxis));
|
|
output.AppendLine(String.Format("UpAxis: {0}", UpAxis));
|
|
output.AppendLine(String.Format("ChangedGrid: {0}", ChangedGrid));
|
|
output.AppendLine(String.Format("Far: {0}", Far));
|
|
output.AppendLine(String.Format("Aspect: {0}", Aspect));
|
|
Helpers.FieldToString(output, Throttles, "Throttles");
|
|
output.Append(Environment.NewLine);
|
|
output.AppendLine(String.Format("LocomotionState: {0}", LocomotionState));
|
|
output.AppendLine(String.Format("HeadRotation: {0}", HeadRotation));
|
|
output.AppendLine(String.Format("BodyRotation: {0}", BodyRotation));
|
|
output.AppendLine(String.Format("ControlFlags: {0}", ControlFlags));
|
|
output.AppendLine(String.Format("EnergyLevel: {0}", EnergyLevel));
|
|
output.AppendLine(String.Format("GodLevel: {0}", GodLevel));
|
|
output.AppendLine(String.Format("AlwaysRun: {0}", AlwaysRun));
|
|
output.AppendLine(String.Format("PreyAgent: {0}", PreyAgent));
|
|
output.AppendLine(String.Format("AgentAccess: {0}", AgentAccess));
|
|
Helpers.FieldToString(output, AgentTextures, "AgentTextures");
|
|
output.Append(Environment.NewLine);
|
|
output.Append(String.Format("ActiveGroupID: {0}", ActiveGroupID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GroupDataBlock : PacketBlock
|
|
{
|
|
public UUID GroupID;
|
|
public ulong GroupPowers;
|
|
public bool AcceptNotices;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 25;
|
|
}
|
|
}
|
|
|
|
public GroupDataBlock() { }
|
|
public GroupDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GroupID.FromBytes(bytes, i); i += 16;
|
|
GroupPowers = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
AcceptNotices = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GroupID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(GroupPowers, bytes, i); i += 8;
|
|
bytes[i++] = (byte)((AcceptNotices) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GroupData --");
|
|
output.AppendLine(String.Format("GroupID: {0}", GroupID));
|
|
output.AppendLine(String.Format("GroupPowers: {0}", GroupPowers));
|
|
output.Append(String.Format("AcceptNotices: {0}", AcceptNotices));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class AnimationDataBlock : PacketBlock
|
|
{
|
|
public UUID Animation;
|
|
public UUID ObjectID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 32;
|
|
}
|
|
}
|
|
|
|
public AnimationDataBlock() { }
|
|
public AnimationDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
Animation.FromBytes(bytes, i); i += 16;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(Animation.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AnimationData --");
|
|
output.AppendLine(String.Format("Animation: {0}", Animation));
|
|
output.Append(String.Format("ObjectID: {0}", ObjectID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class GranterBlockBlock : PacketBlock
|
|
{
|
|
public UUID GranterID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 16;
|
|
}
|
|
}
|
|
|
|
public GranterBlockBlock() { }
|
|
public GranterBlockBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
GranterID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(GranterID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- GranterBlock --");
|
|
output.Append(String.Format("GranterID: {0}", GranterID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class NVPairDataBlock : PacketBlock
|
|
{
|
|
private byte[] _nvpairs;
|
|
public byte[] NVPairs
|
|
{
|
|
get { return _nvpairs; }
|
|
set
|
|
{
|
|
if (value == null) { _nvpairs = null; return; }
|
|
if (value.Length > 1100) { throw new OverflowException("Value exceeds 1100 characters"); }
|
|
else { _nvpairs = new byte[value.Length]; Buffer.BlockCopy(value, 0, _nvpairs, 0, value.Length); }
|
|
}
|
|
}
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
int length = 0;
|
|
if (NVPairs != null) { length += 2 + NVPairs.Length; }
|
|
return length;
|
|
}
|
|
}
|
|
|
|
public NVPairDataBlock() { }
|
|
public NVPairDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
int length;
|
|
try
|
|
{
|
|
length = (ushort)(bytes[i++] + (bytes[i++] << 8));
|
|
_nvpairs = new byte[length];
|
|
Buffer.BlockCopy(bytes, i, _nvpairs, 0, length); i += length;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
if(NVPairs == null) { Console.WriteLine("Warning: NVPairs is null, in " + this.GetType()); }
|
|
bytes[i++] = (byte)(NVPairs.Length % 256);
|
|
bytes[i++] = (byte)((NVPairs.Length >> 8) % 256);
|
|
Buffer.BlockCopy(NVPairs, 0, bytes, i, NVPairs.Length); i += NVPairs.Length;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- NVPairData --");
|
|
Helpers.FieldToString(output, NVPairs, "NVPairs");
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class VisualParamBlock : PacketBlock
|
|
{
|
|
public byte ParamValue;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
public VisualParamBlock() { }
|
|
public VisualParamBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
ParamValue = (byte)bytes[i++];
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
bytes[i++] = ParamValue;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- VisualParam --");
|
|
output.Append(String.Format("ParamValue: {0}", ParamValue));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChildAgentUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
public GroupDataBlock[] GroupData;
|
|
public AnimationDataBlock[] AnimationData;
|
|
public GranterBlockBlock[] GranterBlock;
|
|
public NVPairDataBlock[] NVPairData;
|
|
public VisualParamBlock[] VisualParam;
|
|
|
|
public ChildAgentUpdatePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 25;
|
|
Header.Reliable = true;
|
|
Header.Zerocoded = true;
|
|
AgentData = new AgentDataBlock();
|
|
GroupData = new GroupDataBlock[0];
|
|
AnimationData = new AnimationDataBlock[0];
|
|
GranterBlock = new GranterBlockBlock[0];
|
|
NVPairData = new NVPairDataBlock[0];
|
|
VisualParam = new VisualParamBlock[0];
|
|
}
|
|
|
|
public ChildAgentUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(AnimationData.Length < count) {
|
|
AnimationData = new AnimationDataBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationData[j] = new AnimationDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(GranterBlock.Length < count) {
|
|
GranterBlock = new GranterBlockBlock[count];
|
|
for(int j = 0; j < count; j++) GranterBlock[j] = new GranterBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GranterBlock[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(NVPairData.Length < count) {
|
|
NVPairData = new NVPairDataBlock[count];
|
|
for(int j = 0; j < count; j++) NVPairData[j] = new NVPairDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ NVPairData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(VisualParam.Length < count) {
|
|
VisualParam = new VisualParamBlock[count];
|
|
for(int j = 0; j < count; j++) VisualParam[j] = new VisualParamBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VisualParam[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public ChildAgentUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
int count = (int)bytes[i++];
|
|
if(GroupData.Length < count) {
|
|
GroupData = new GroupDataBlock[count];
|
|
for(int j = 0; j < count; j++) GroupData[j] = new GroupDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GroupData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(AnimationData.Length < count) {
|
|
AnimationData = new AnimationDataBlock[count];
|
|
for(int j = 0; j < count; j++) AnimationData[j] = new AnimationDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ AnimationData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(GranterBlock.Length < count) {
|
|
GranterBlock = new GranterBlockBlock[count];
|
|
for(int j = 0; j < count; j++) GranterBlock[j] = new GranterBlockBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ GranterBlock[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(NVPairData.Length < count) {
|
|
NVPairData = new NVPairDataBlock[count];
|
|
for(int j = 0; j < count; j++) NVPairData[j] = new NVPairDataBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ NVPairData[j].FromBytes(bytes, ref i); }
|
|
count = (int)bytes[i++];
|
|
if(VisualParam.Length < count) {
|
|
VisualParam = new VisualParamBlock[count];
|
|
for(int j = 0; j < count; j++) VisualParam[j] = new VisualParamBlock();
|
|
}
|
|
for (int j = 0; j < count; j++)
|
|
{ VisualParam[j].FromBytes(bytes, ref i); }
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
length++;
|
|
for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < AnimationData.Length; j++) { length += AnimationData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < GranterBlock.Length; j++) { length += GranterBlock[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < NVPairData.Length; j++) { length += NVPairData[j].Length; }
|
|
length++;
|
|
for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; }
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
bytes[i++] = (byte)GroupData.Length;
|
|
for (int j = 0; j < GroupData.Length; j++) { GroupData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)AnimationData.Length;
|
|
for (int j = 0; j < AnimationData.Length; j++) { AnimationData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)GranterBlock.Length;
|
|
for (int j = 0; j < GranterBlock.Length; j++) { GranterBlock[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)NVPairData.Length;
|
|
for (int j = 0; j < NVPairData.Length; j++) { NVPairData[j].ToBytes(bytes, ref i); }
|
|
bytes[i++] = (byte)VisualParam.Length;
|
|
for (int j = 0; j < VisualParam.Length; j++) { VisualParam[j].ToBytes(bytes, ref i); }
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChildAgentUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
for (int j = 0; j < GroupData.Length; j++)
|
|
{
|
|
output += GroupData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < AnimationData.Length; j++)
|
|
{
|
|
output += AnimationData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < GranterBlock.Length; j++)
|
|
{
|
|
output += GranterBlock[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < NVPairData.Length; j++)
|
|
{
|
|
output += NVPairData[j].ToString() + Environment.NewLine;
|
|
}
|
|
for (int j = 0; j < VisualParam.Length; j++)
|
|
{
|
|
output += VisualParam[j].ToString() + Environment.NewLine;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChildAgentAlivePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public uint ViewerCircuitCode;
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 44;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
Utils.UIntToBytes(ViewerCircuitCode, bytes, i); i += 4;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.AppendLine(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.Append(String.Format("SessionID: {0}", SessionID));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChildAgentAlive; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ChildAgentAlivePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 26;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ChildAgentAlivePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ChildAgentAlivePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChildAgentAlive ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class ChildAgentPositionUpdatePacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class AgentDataBlock : PacketBlock
|
|
{
|
|
public ulong RegionHandle;
|
|
public uint ViewerCircuitCode;
|
|
public UUID AgentID;
|
|
public UUID SessionID;
|
|
public Vector3 AgentPos;
|
|
public Vector3 AgentVel;
|
|
public Vector3 Center;
|
|
public Vector3 Size;
|
|
public Vector3 AtAxis;
|
|
public Vector3 LeftAxis;
|
|
public Vector3 UpAxis;
|
|
public bool ChangedGrid;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 129;
|
|
}
|
|
}
|
|
|
|
public AgentDataBlock() { }
|
|
public AgentDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
RegionHandle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
ViewerCircuitCode = (uint)(bytes[i++] + (bytes[i++] << 8) + (bytes[i++] << 16) + (bytes[i++] << 24));
|
|
AgentID.FromBytes(bytes, i); i += 16;
|
|
SessionID.FromBytes(bytes, i); i += 16;
|
|
AgentPos.FromBytes(bytes, i); i += 12;
|
|
AgentVel.FromBytes(bytes, i); i += 12;
|
|
Center.FromBytes(bytes, i); i += 12;
|
|
Size.FromBytes(bytes, i); i += 12;
|
|
AtAxis.FromBytes(bytes, i); i += 12;
|
|
LeftAxis.FromBytes(bytes, i); i += 12;
|
|
UpAxis.FromBytes(bytes, i); i += 12;
|
|
ChangedGrid = (bytes[i++] != 0) ? (bool)true : (bool)false;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Utils.UInt64ToBytes(RegionHandle, bytes, i); i += 8;
|
|
Utils.UIntToBytes(ViewerCircuitCode, bytes, i); i += 4;
|
|
Buffer.BlockCopy(AgentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(SessionID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(AgentPos.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(AgentVel.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Center.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(Size.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(AtAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(LeftAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Buffer.BlockCopy(UpAxis.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
bytes[i++] = (byte)((ChangedGrid) ? 1 : 0);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- AgentData --");
|
|
output.AppendLine(String.Format("RegionHandle: {0}", RegionHandle));
|
|
output.AppendLine(String.Format("ViewerCircuitCode: {0}", ViewerCircuitCode));
|
|
output.AppendLine(String.Format("AgentID: {0}", AgentID));
|
|
output.AppendLine(String.Format("SessionID: {0}", SessionID));
|
|
output.AppendLine(String.Format("AgentPos: {0}", AgentPos));
|
|
output.AppendLine(String.Format("AgentVel: {0}", AgentVel));
|
|
output.AppendLine(String.Format("Center: {0}", Center));
|
|
output.AppendLine(String.Format("Size: {0}", Size));
|
|
output.AppendLine(String.Format("AtAxis: {0}", AtAxis));
|
|
output.AppendLine(String.Format("LeftAxis: {0}", LeftAxis));
|
|
output.AppendLine(String.Format("UpAxis: {0}", UpAxis));
|
|
output.Append(String.Format("ChangedGrid: {0}", ChangedGrid));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.ChildAgentPositionUpdate; } }
|
|
public AgentDataBlock AgentData;
|
|
|
|
public ChildAgentPositionUpdatePacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 27;
|
|
Header.Reliable = true;
|
|
AgentData = new AgentDataBlock();
|
|
}
|
|
|
|
public ChildAgentPositionUpdatePacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public ChildAgentPositionUpdatePacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
AgentData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += AgentData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
AgentData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- ChildAgentPositionUpdate ---" + Environment.NewLine;
|
|
output += AgentData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
/// <exclude/>
|
|
public class SoundTriggerPacket : Packet
|
|
{
|
|
/// <exclude/>
|
|
public class SoundDataBlock : PacketBlock
|
|
{
|
|
public UUID SoundID;
|
|
public UUID OwnerID;
|
|
public UUID ObjectID;
|
|
public UUID ParentID;
|
|
public ulong Handle;
|
|
public Vector3 Position;
|
|
public float Gain;
|
|
|
|
public override int Length
|
|
{
|
|
get
|
|
{
|
|
return 88;
|
|
}
|
|
}
|
|
|
|
public SoundDataBlock() { }
|
|
public SoundDataBlock(byte[] bytes, ref int i)
|
|
{
|
|
FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override void FromBytes(byte[] bytes, ref int i)
|
|
{
|
|
try
|
|
{
|
|
SoundID.FromBytes(bytes, i); i += 16;
|
|
OwnerID.FromBytes(bytes, i); i += 16;
|
|
ObjectID.FromBytes(bytes, i); i += 16;
|
|
ParentID.FromBytes(bytes, i); i += 16;
|
|
Handle = (ulong)((ulong)bytes[i++] + ((ulong)bytes[i++] << 8) + ((ulong)bytes[i++] << 16) + ((ulong)bytes[i++] << 24) + ((ulong)bytes[i++] << 32) + ((ulong)bytes[i++] << 40) + ((ulong)bytes[i++] << 48) + ((ulong)bytes[i++] << 56));
|
|
Position.FromBytes(bytes, i); i += 12;
|
|
Gain = Utils.BytesToFloat(bytes, i); i += 4;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
throw new MalformedDataException();
|
|
}
|
|
}
|
|
|
|
public override void ToBytes(byte[] bytes, ref int i)
|
|
{
|
|
Buffer.BlockCopy(SoundID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(OwnerID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ObjectID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Buffer.BlockCopy(ParentID.GetBytes(), 0, bytes, i, 16); i += 16;
|
|
Utils.UInt64ToBytes(Handle, bytes, i); i += 8;
|
|
Buffer.BlockCopy(Position.GetBytes(), 0, bytes, i, 12); i += 12;
|
|
Utils.FloatToBytes(Gain, bytes, i); i += 4;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
StringBuilder output = new StringBuilder();
|
|
output.AppendLine("-- SoundData --");
|
|
output.AppendLine(String.Format("SoundID: {0}", SoundID));
|
|
output.AppendLine(String.Format("OwnerID: {0}", OwnerID));
|
|
output.AppendLine(String.Format("ObjectID: {0}", ObjectID));
|
|
output.AppendLine(String.Format("ParentID: {0}", ParentID));
|
|
output.AppendLine(String.Format("Handle: {0}", Handle));
|
|
output.AppendLine(String.Format("Position: {0}", Position));
|
|
output.Append(String.Format("Gain: {0}", Gain));
|
|
return output.ToString();
|
|
}
|
|
}
|
|
|
|
private Header header;
|
|
public override Header Header { get { return header; } set { header = value; } }
|
|
public override PacketType Type { get { return PacketType.SoundTrigger; } }
|
|
public SoundDataBlock SoundData;
|
|
|
|
public SoundTriggerPacket()
|
|
{
|
|
Header = new HighHeader();
|
|
Header.ID = 29;
|
|
Header.Reliable = true;
|
|
SoundData = new SoundDataBlock();
|
|
}
|
|
|
|
public SoundTriggerPacket(byte[] bytes, ref int i) : this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
header.FromBytes(bytes, ref i, ref packetEnd);
|
|
if (header.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
SoundData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public SoundTriggerPacket(Header head, byte[] bytes, ref int i): this()
|
|
{
|
|
int packetEnd = bytes.Length - 1;
|
|
FromBytes(head, bytes, ref i, ref packetEnd, null);
|
|
}
|
|
|
|
override public void FromBytes(Header head, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer)
|
|
{
|
|
Header = head;
|
|
if (head.Zerocoded && zeroBuffer != null)
|
|
{
|
|
packetEnd = Helpers.ZeroDecode(bytes, packetEnd + 1, zeroBuffer) - 1;
|
|
bytes = zeroBuffer;
|
|
}
|
|
SoundData.FromBytes(bytes, ref i);
|
|
}
|
|
|
|
public override byte[] ToBytes()
|
|
{
|
|
int length = 7;
|
|
length += SoundData.Length;;
|
|
if (header.AckList.Length > 0) { length += header.AckList.Length * 4 + 1; }
|
|
byte[] bytes = new byte[length];
|
|
int i = 0;
|
|
header.ToBytes(bytes, ref i);
|
|
SoundData.ToBytes(bytes, ref i);
|
|
if (header.AckList.Length > 0) { header.AcksToBytes(bytes, ref i); }
|
|
return bytes;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string output = "--- SoundTrigger ---" + Environment.NewLine;
|
|
output += SoundData.ToString() + Environment.NewLine;
|
|
return output;
|
|
}
|
|
|
|
}
|
|
|
|
}
|