diff --git a/OpenMetaverse.Tests/PacketTests.cs b/OpenMetaverse.Tests/PacketTests.cs index 40aa1af4..b7771337 100644 --- a/OpenMetaverse.Tests/PacketTests.cs +++ b/OpenMetaverse.Tests/PacketTests.cs @@ -90,5 +90,70 @@ namespace OpenMetaverse.Tests Assert.IsFalse(packet.Header.Resent, "Resent: Failed to set the flag back to false"); Assert.IsFalse(packet.Header.Zerocoded, "Zerocoded: Failed to set the flag back to false"); } + + [Test] + public void ToBytesMultiple() + { + UUID testID = UUID.Random(); + + DirPlacesReplyPacket bigPacket = new DirPlacesReplyPacket(); + bigPacket.Header.Zerocoded = false; + bigPacket.Header.Sequence = 42; + bigPacket.Header.AppendedAcks = true; + bigPacket.Header.AckList = new uint[50]; + for (int i = 0; i < bigPacket.Header.AckList.Length; i++) { bigPacket.Header.AckList[i] = (uint)i; } + bigPacket.AgentData.AgentID = testID; + bigPacket.QueryData = new DirPlacesReplyPacket.QueryDataBlock[100]; + for (int i = 0; i < bigPacket.QueryData.Length; i++) + { + bigPacket.QueryData[i] = new DirPlacesReplyPacket.QueryDataBlock(); + bigPacket.QueryData[i].QueryID = testID; + } + bigPacket.QueryReplies = new DirPlacesReplyPacket.QueryRepliesBlock[100]; + for (int i = 0; i < bigPacket.QueryReplies.Length; i++) + { + bigPacket.QueryReplies[i] = new DirPlacesReplyPacket.QueryRepliesBlock(); + bigPacket.QueryReplies[i].Auction = (i & 1) == 0; + bigPacket.QueryReplies[i].Dwell = (float)i; + bigPacket.QueryReplies[i].ForSale = (i & 1) == 0; + bigPacket.QueryReplies[i].Name = Utils.StringToBytes("DirPlacesReply Test String"); + bigPacket.QueryReplies[i].ParcelID = testID; + } + bigPacket.StatusData = new DirPlacesReplyPacket.StatusDataBlock[100]; + for (int i = 0; i < bigPacket.StatusData.Length; i++) + { + bigPacket.StatusData[i] = new DirPlacesReplyPacket.StatusDataBlock(); + bigPacket.StatusData[i].Status = (uint)i; + } + + byte[][] splitPackets = bigPacket.ToBytesMultiple(); + + int queryDataCount = 0; + int queryRepliesCount = 0; + int statusDataCount = 0; + for (int i = 0; i < splitPackets.Length; i++) + { + byte[] packetData = splitPackets[i]; + int len = packetData.Length - 1; + DirPlacesReplyPacket packet = (DirPlacesReplyPacket)Packet.BuildPacket(packetData, ref len, packetData); + + Assert.IsTrue(packet.AgentData.AgentID == bigPacket.AgentData.AgentID); + + for (int j = 0; j < packet.QueryReplies.Length; j++) + { + Assert.IsTrue(packet.QueryReplies[j].Dwell == (float)(queryRepliesCount + j), + "Expected Dwell of " + (float)(queryRepliesCount + j) + " but got " + packet.QueryReplies[j].Dwell); + Assert.IsTrue(packet.QueryReplies[j].ParcelID == testID); + } + + queryDataCount += packet.QueryData.Length; + queryRepliesCount += packet.QueryReplies.Length; + statusDataCount += packet.StatusData.Length; + } + + Assert.IsTrue(queryDataCount == bigPacket.QueryData.Length); + Assert.IsTrue(queryRepliesCount == bigPacket.QueryData.Length); + Assert.IsTrue(statusDataCount == bigPacket.StatusData.Length); + } } } diff --git a/OpenMetaverse/_Packets_.cs b/OpenMetaverse/_Packets_.cs index e26a4127..3b328c2e 100644 --- a/OpenMetaverse/_Packets_.cs +++ b/OpenMetaverse/_Packets_.cs @@ -636,12 +636,16 @@ namespace OpenMetaverse.Packets public abstract partial class Packet { + public const int MTU = 1200; + public Header Header; public PacketType Type; public abstract int Length { 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 abstract byte[][] ToBytesMultiple(); + public static PacketType GetType(ushort id, PacketFrequency frequency) { switch (frequency) @@ -2049,7 +2053,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TestBlock1.Length;; + length += TestBlock1.Length; for (int j = 0; j < 4; j++) { length += NeighborBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; @@ -2061,6 +2065,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -2168,7 +2176,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += CircuitCode.Length;; + length += CircuitCode.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -2178,6 +2186,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -2360,7 +2372,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TelehubBlock.Length;; + length += TelehubBlock.Length; length++; for (int j = 0; j < SpawnPointBlock.Length; j++) { length += SpawnPointBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -2374,6 +2386,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += TelehubBlock.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + TelehubBlock.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int SpawnPointBlockStart = 0; + while ( + SpawnPointBlockStart < SpawnPointBlock.Length) + { + int variableLength = 0; + int SpawnPointBlockCount = 0; + + i = SpawnPointBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < SpawnPointBlock.Length) { + int blockLength = SpawnPointBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++SpawnPointBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)SpawnPointBlockCount; + for (i = SpawnPointBlockStart; i < SpawnPointBlockStart + SpawnPointBlockCount; i++) { SpawnPointBlock[i].ToBytes(packet, ref length); } + SpawnPointBlockStart += SpawnPointBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -2432,7 +2501,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -2441,6 +2509,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -2591,7 +2663,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -2601,6 +2673,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -2767,7 +2843,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -2778,6 +2855,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -2974,7 +3055,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -2988,6 +3069,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -3221,7 +3359,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += TransactionData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -3233,6 +3373,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -3517,7 +3661,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionData.Length;; + length += AgentData.Length; + length += TransactionData.Length; length++; for (int j = 0; j < QueryData.Length; j++) { length += QueryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -3532,6 +3677,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += TransactionData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + TransactionData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int QueryDataStart = 0; + while ( + QueryDataStart < QueryData.Length) + { + int variableLength = 0; + int QueryDataCount = 0; + + i = QueryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryData.Length) { + int blockLength = QueryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryDataCount; + for (i = QueryDataStart; i < QueryDataStart + QueryDataCount; i++) { QueryData[i].ToBytes(packet, ref length); } + QueryDataStart += QueryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -3705,7 +3909,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -3716,6 +3921,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -3909,7 +4118,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -3920,6 +4130,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -4218,7 +4432,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < QueryData.Length; j++) { length += QueryData[j].Length; } length++; @@ -4240,6 +4454,99 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 3; + + int QueryDataStart = 0; + int QueryRepliesStart = 0; + int StatusDataStart = 0; + while ( + QueryDataStart < QueryData.Length || + QueryRepliesStart < QueryReplies.Length || + StatusDataStart < StatusData.Length) + { + int variableLength = 0; + int QueryDataCount = 0; + int QueryRepliesCount = 0; + int StatusDataCount = 0; + + i = QueryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryData.Length) { + int blockLength = QueryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryDataCount; + } + else { break; } + ++i; + } + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + i = StatusDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < StatusData.Length) { + int blockLength = StatusData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++StatusDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryDataCount; + for (i = QueryDataStart; i < QueryDataStart + QueryDataCount; i++) { QueryData[i].ToBytes(packet, ref length); } + QueryDataStart += QueryDataCount; + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + packet[length++] = (byte)StatusDataCount; + for (i = StatusDataStart; i < StatusDataStart + StatusDataCount; i++) { StatusData[i].ToBytes(packet, ref length); } + StatusDataStart += StatusDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -4500,7 +4807,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; length++; for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -4515,6 +4823,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += QueryData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + QueryData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int QueryRepliesStart = 0; + while ( + QueryRepliesStart < QueryReplies.Length) + { + int variableLength = 0; + int QueryRepliesCount = 0; + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -4817,7 +5184,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; length++; for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; } length++; @@ -4836,6 +5204,83 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += QueryData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + QueryData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int QueryRepliesStart = 0; + int StatusDataStart = 0; + while ( + QueryRepliesStart < QueryReplies.Length || + StatusDataStart < StatusData.Length) + { + int variableLength = 0; + int QueryRepliesCount = 0; + int StatusDataCount = 0; + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + i = StatusDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < StatusData.Length) { + int blockLength = StatusData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++StatusDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + packet[length++] = (byte)StatusDataCount; + for (i = StatusDataStart; i < StatusDataStart + StatusDataCount; i++) { StatusData[i].ToBytes(packet, ref length); } + StatusDataStart += StatusDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -5062,7 +5507,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; length++; for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -5077,6 +5523,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += QueryData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + QueryData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int QueryRepliesStart = 0; + while ( + QueryRepliesStart < QueryReplies.Length) + { + int variableLength = 0; + int QueryRepliesCount = 0; + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -5253,7 +5758,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -5264,6 +5770,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -5552,7 +6062,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; length++; for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; } length++; @@ -5571,6 +6082,83 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += QueryData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + QueryData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int QueryRepliesStart = 0; + int StatusDataStart = 0; + while ( + QueryRepliesStart < QueryReplies.Length || + StatusDataStart < StatusData.Length) + { + int variableLength = 0; + int QueryRepliesCount = 0; + int StatusDataCount = 0; + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + i = StatusDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < StatusData.Length) { + int blockLength = StatusData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++StatusDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + packet[length++] = (byte)StatusDataCount; + for (i = StatusDataStart; i < StatusDataStart + StatusDataCount; i++) { StatusData[i].ToBytes(packet, ref length); } + StatusDataStart += StatusDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -5750,7 +6338,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -5764,6 +6352,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -5912,7 +6557,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -5923,6 +6569,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -6168,7 +6818,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -6179,6 +6830,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -6384,7 +7039,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -6395,6 +7051,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -6542,7 +7202,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -6553,6 +7214,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -6703,7 +7368,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -6714,6 +7380,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -6877,7 +7547,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -6888,6 +7559,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -7120,7 +7795,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; length++; for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -7135,6 +7811,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += QueryData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + QueryData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int QueryRepliesStart = 0; + while ( + QueryRepliesStart < QueryReplies.Length) + { + int variableLength = 0; + int QueryRepliesCount = 0; + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -7286,7 +8021,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -7297,6 +8033,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -7520,7 +8260,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += QueryData.Length; length++; for (int j = 0; j < QueryReplies.Length; j++) { length += QueryReplies[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -7535,6 +8276,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += QueryData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + QueryData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int QueryRepliesStart = 0; + while ( + QueryRepliesStart < QueryReplies.Length) + { + int variableLength = 0; + int QueryRepliesCount = 0; + + i = QueryRepliesStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < QueryReplies.Length) { + int blockLength = QueryReplies[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++QueryRepliesCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)QueryRepliesCount; + for (i = QueryRepliesStart; i < QueryRepliesStart + QueryRepliesCount; i++) { QueryReplies[i].ToBytes(packet, ref length); } + QueryRepliesStart += QueryRepliesCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -7682,7 +8482,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -7693,6 +8494,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -7924,7 +8729,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -7935,6 +8741,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -8082,7 +8892,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -8093,6 +8904,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -8217,7 +9032,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -8230,6 +9044,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -8377,7 +9246,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -8388,6 +9258,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -8595,7 +9469,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -8609,6 +9483,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -8756,7 +9687,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -8767,6 +9699,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -8920,7 +9856,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Info.Length;; + length += AgentData.Length; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -8931,6 +9868,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -9084,7 +10025,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Info.Length;; + length += AgentData.Length; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -9095,6 +10037,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -9208,7 +10154,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -9218,6 +10164,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -9326,7 +10276,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -9336,6 +10286,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -9499,7 +10453,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Info.Length;; + length += AgentData.Length; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -9510,6 +10465,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -9650,7 +10609,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -9660,6 +10619,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -9882,7 +10845,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Info.Length;; + length += AgentData.Length; + length += Info.Length; length++; for (int j = 0; j < TargetData.Length; j++) { length += TargetData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -9897,6 +10861,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += Info.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + Info.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int TargetDataStart = 0; + while ( + TargetDataStart < TargetData.Length) + { + int variableLength = 0; + int TargetDataCount = 0; + + i = TargetDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < TargetData.Length) { + int blockLength = TargetData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++TargetDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)TargetDataCount; + for (i = TargetDataStart; i < TargetDataStart + TargetDataCount; i++) { TargetData[i].ToBytes(packet, ref length); } + TargetDataStart += TargetDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -10007,7 +11030,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -10017,6 +11040,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -10121,7 +11148,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -10131,6 +11158,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -10232,7 +11263,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -10242,6 +11273,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -10451,7 +11486,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Info.Length;; + length += Info.Length; length++; for (int j = 0; j < AlertInfo.Length; j++) { length += AlertInfo[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -10465,6 +11500,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Info.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Info.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int AlertInfoStart = 0; + while ( + AlertInfoStart < AlertInfo.Length) + { + int variableLength = 0; + int AlertInfoCount = 0; + + i = AlertInfoStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AlertInfo.Length) { + int blockLength = AlertInfo[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AlertInfoCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AlertInfoCount; + for (i = AlertInfoStart; i < AlertInfoStart + AlertInfoCount; i++) { AlertInfo[i].ToBytes(packet, ref length); } + AlertInfoStart += AlertInfoCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -10628,7 +11720,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -10642,6 +11734,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -10805,7 +11954,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -10819,6 +11968,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -10923,7 +12129,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -10933,6 +12139,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -11040,7 +12250,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -11050,6 +12260,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -11157,7 +12371,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -11167,6 +12381,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -11338,7 +12556,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ChatData.Length;; + length += AgentData.Length; + length += ChatData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -11349,6 +12568,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -11519,7 +12742,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Throttle.Length;; + length += AgentData.Length; + length += Throttle.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -11530,6 +12754,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -11683,7 +12911,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += FOVBlock.Length;; + length += AgentData.Length; + length += FOVBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -11694,6 +12923,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -11852,7 +13085,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += HeightWidthBlock.Length;; + length += AgentData.Length; + length += HeightWidthBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -11863,6 +13097,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -12149,7 +13387,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; length++; for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; } length++; @@ -12168,6 +13407,83 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int WearableDataStart = 0; + int VisualParamStart = 0; + while ( + WearableDataStart < WearableData.Length || + VisualParamStart < VisualParam.Length) + { + int variableLength = 0; + int WearableDataCount = 0; + int VisualParamCount = 0; + + i = WearableDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < WearableData.Length) { + int blockLength = WearableData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++WearableDataCount; + } + else { break; } + ++i; + } + + i = VisualParamStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < VisualParam.Length) { + int blockLength = VisualParam[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++VisualParamCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)WearableDataCount; + for (i = WearableDataStart; i < WearableDataStart + WearableDataCount; i++) { WearableData[i].ToBytes(packet, ref length); } + WearableDataStart += WearableDataCount; + + packet[length++] = (byte)VisualParamCount; + for (i = VisualParamStart; i < VisualParamStart + VisualParamCount; i++) { VisualParam[i].ToBytes(packet, ref length); } + VisualParamStart += VisualParamCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -12315,7 +13631,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += FuseBlock.Length;; + length += AgentData.Length; + length += FuseBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -12326,6 +13643,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -12427,7 +13748,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ImageID.Length;; + length += ImageID.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -12437,6 +13758,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -12538,7 +13863,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TextureData.Length;; + length += TextureData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -12548,6 +13873,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -12655,7 +13984,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -12665,6 +13994,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -12829,7 +14162,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -12843,6 +14176,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -13053,7 +14443,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += SharedData.Length;; + length += AgentData.Length; + length += SharedData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -13068,6 +14459,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += SharedData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + SharedData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -13256,7 +14706,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -13270,6 +14720,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -13434,7 +14941,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -13448,6 +14955,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -13612,7 +15176,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -13626,6 +15190,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -13746,7 +15367,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -13756,6 +15377,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -13920,7 +15545,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -13934,6 +15559,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -14132,7 +15814,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -14146,6 +15828,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -14310,7 +16049,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -14324,6 +16063,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -14544,7 +16340,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -14558,6 +16354,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -14748,7 +16601,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -14762,6 +16615,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -14972,7 +16882,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += HeaderData.Length;; + length += AgentData.Length; + length += HeaderData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -14987,6 +16898,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += HeaderData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + HeaderData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -15151,7 +17121,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -15165,6 +17135,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -15338,7 +17365,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -15352,6 +17379,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -15506,7 +17590,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -15517,6 +17602,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -15622,7 +17711,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -15632,6 +17721,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -15845,7 +17938,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += HeaderData.Length;; + length += AgentData.Length; + length += HeaderData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -15860,6 +17954,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += HeaderData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + HeaderData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -16027,7 +18180,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -16041,6 +18194,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -16221,7 +18431,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -16235,6 +18445,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -16415,7 +18682,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -16429,6 +18696,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -16593,7 +18917,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -16607,6 +18931,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -16768,7 +19149,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -16782,6 +19163,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -16943,7 +19381,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -16957,6 +19395,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -17124,7 +19619,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -17138,6 +19633,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -17298,7 +19850,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -17312,6 +19864,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -17472,7 +20081,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -17486,6 +20095,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -17646,7 +20312,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -17660,6 +20326,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -17820,7 +20543,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -17834,6 +20557,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -18056,7 +20836,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; length++; for (int j = 0; j < SurfaceInfo.Length; j++) { length += SurfaceInfo[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -18071,6 +20852,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int SurfaceInfoStart = 0; + while ( + SurfaceInfoStart < SurfaceInfo.Length) + { + int variableLength = 0; + int SurfaceInfoCount = 0; + + i = SurfaceInfoStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < SurfaceInfo.Length) { + int blockLength = SurfaceInfo[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++SurfaceInfoCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)SurfaceInfoCount; + for (i = SurfaceInfoStart; i < SurfaceInfoStart + SurfaceInfoCount; i++) { SurfaceInfo[i].ToBytes(packet, ref length); } + SurfaceInfoStart += SurfaceInfoCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -18299,7 +21139,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; length++; for (int j = 0; j < SurfaceInfo.Length; j++) { length += SurfaceInfo[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -18314,6 +21155,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int SurfaceInfoStart = 0; + while ( + SurfaceInfoStart < SurfaceInfo.Length) + { + int variableLength = 0; + int SurfaceInfoCount = 0; + + i = SurfaceInfoStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < SurfaceInfo.Length) { + int blockLength = SurfaceInfo[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++SurfaceInfoCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)SurfaceInfoCount; + for (i = SurfaceInfoStart; i < SurfaceInfoStart + SurfaceInfoCount; i++) { SurfaceInfo[i].ToBytes(packet, ref length); } + SurfaceInfoStart += SurfaceInfoCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -18532,7 +21432,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; length++; for (int j = 0; j < SurfaceInfo.Length; j++) { length += SurfaceInfo[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -18547,6 +21448,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int SurfaceInfoStart = 0; + while ( + SurfaceInfoStart < SurfaceInfo.Length) + { + int variableLength = 0; + int SurfaceInfoCount = 0; + + i = SurfaceInfoStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < SurfaceInfo.Length) { + int blockLength = SurfaceInfo[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++SurfaceInfoCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)SurfaceInfoCount; + for (i = SurfaceInfoStart; i < SurfaceInfoStart + SurfaceInfoCount; i++) { SurfaceInfo[i].ToBytes(packet, ref length); } + SurfaceInfoStart += SurfaceInfoCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -18695,7 +21655,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -18706,6 +21667,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -18857,7 +21822,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -18868,6 +21834,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -19016,7 +21986,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -19027,6 +21998,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -19192,7 +22167,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -19206,6 +22181,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -19487,7 +22519,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ModifyBlock.Length;; + length += AgentData.Length; + length += ModifyBlock.Length; length++; for (int j = 0; j < ParcelData.Length; j++) { length += ParcelData[j].Length; } length++; @@ -19506,6 +22539,83 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ModifyBlock.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ModifyBlock.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int ParcelDataStart = 0; + int ModifyBlockExtendedStart = 0; + while ( + ParcelDataStart < ParcelData.Length || + ModifyBlockExtendedStart < ModifyBlockExtended.Length) + { + int variableLength = 0; + int ParcelDataCount = 0; + int ModifyBlockExtendedCount = 0; + + i = ParcelDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ParcelData.Length) { + int blockLength = ParcelData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ParcelDataCount; + } + else { break; } + ++i; + } + + i = ModifyBlockExtendedStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ModifyBlockExtended.Length) { + int blockLength = ModifyBlockExtended[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ModifyBlockExtendedCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ParcelDataCount; + for (i = ParcelDataStart; i < ParcelDataStart + ParcelDataCount; i++) { ParcelData[i].ToBytes(packet, ref length); } + ParcelDataStart += ParcelDataCount; + + packet[length++] = (byte)ModifyBlockExtendedCount; + for (i = ModifyBlockExtendedStart; i < ModifyBlockExtendedStart + ModifyBlockExtendedCount; i++) { ModifyBlockExtended[i].ToBytes(packet, ref length); } + ModifyBlockExtendedStart += ModifyBlockExtendedCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -19610,7 +22720,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -19620,6 +22730,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -19724,7 +22838,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -19734,6 +22848,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -19897,7 +23015,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += DataBlock.Length;; + length += AgentData.Length; + length += DataBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -19908,6 +23027,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -20012,7 +23135,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AutosaveData.Length;; + length += AutosaveData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -20022,6 +23145,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -20172,7 +23299,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += DataBlock.Length;; + length += AgentData.Length; + length += DataBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -20183,6 +23311,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -20330,7 +23462,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TargetData.Length;; + length += AgentData.Length; + length += TargetData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -20341,6 +23474,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -20758,7 +23895,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += DownloadTotals.Length; length += FailStats.Length;; + 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; } @@ -20776,6 +23915,69 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += DownloadTotals.Length; + for (int j = 0; j < 2; j++) { fixedLength += NetStats[j].Length; } + fixedLength += FailStats.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + DownloadTotals.ToBytes(fixedBytes, ref i); + for (int j = 0; j < 2; j++) { NetStats[j].ToBytes(fixedBytes, ref i); } + FailStats.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int MiscStatsStart = 0; + while ( + MiscStatsStart < MiscStats.Length) + { + int variableLength = 0; + int MiscStatsCount = 0; + + i = MiscStatsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < MiscStats.Length) { + int blockLength = MiscStats[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++MiscStatsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)MiscStatsCount; + for (i = MiscStatsStart; i < MiscStatsStart + MiscStatsCount; i++) { MiscStats[i].ToBytes(packet, ref length); } + MiscStatsStart += MiscStatsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -20929,7 +24131,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -20940,6 +24143,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -21180,7 +24387,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ReportData.Length;; + length += AgentData.Length; + length += ReportData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -21191,6 +24399,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -21397,7 +24609,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AlertData.Length;; + length += AlertData.Length; length++; for (int j = 0; j < AlertInfo.Length; j++) { length += AlertInfo[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -21411,6 +24623,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AlertData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AlertData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int AlertInfoStart = 0; + while ( + AlertInfoStart < AlertInfo.Length) + { + int variableLength = 0; + int AlertInfoCount = 0; + + i = AlertInfoStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AlertInfo.Length) { + int blockLength = AlertInfo[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AlertInfoCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AlertInfoCount; + for (i = AlertInfoStart; i < AlertInfoStart + AlertInfoCount; i++) { AlertInfo[i].ToBytes(packet, ref length); } + AlertInfoStart += AlertInfoCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -21574,7 +24843,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += AlertData.Length;; + length += AgentData.Length; + length += AlertData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -21585,6 +24855,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -21712,7 +24986,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < MeanCollision.Length; j++) { length += MeanCollision[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -21725,6 +24998,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int MeanCollisionStart = 0; + while ( + MeanCollisionStart < MeanCollision.Length) + { + int variableLength = 0; + int MeanCollisionCount = 0; + + i = MeanCollisionStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < MeanCollision.Length) { + int blockLength = MeanCollision[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++MeanCollisionCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)MeanCollisionCount; + for (i = MeanCollisionStart; i < MeanCollisionStart + MeanCollisionCount; i++) { MeanCollision[i].ToBytes(packet, ref length); } + MeanCollisionStart += MeanCollisionCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -21826,7 +25154,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += FrozenData.Length;; + length += FrozenData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -21836,6 +25164,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -21938,7 +25270,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += HealthData.Length;; + length += HealthData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -21948,6 +25280,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -22101,7 +25437,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ChatData.Length;; + length += ChatData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -22111,6 +25447,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -22323,7 +25663,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Region.Length; length += PidStat.Length;; + length += Region.Length; + length += PidStat.Length; length++; for (int j = 0; j < Stat.Length; j++) { length += Stat[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -22338,6 +25679,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Region.Length; + fixedLength += PidStat.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Region.ToBytes(fixedBytes, ref i); + PidStat.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int StatStart = 0; + while ( + StatStart < Stat.Length) + { + int variableLength = 0; + int StatCount = 0; + + i = StatStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Stat.Length) { + int blockLength = Stat[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++StatCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)StatCount; + for (i = StatStart; i < StatStart + StatCount; i++) { Stat[i].ToBytes(packet, ref length); } + StatStart += StatCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -22442,7 +25842,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -22452,6 +25852,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -22746,7 +26150,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RegionInfo.Length; length += RegionInfo2.Length;; + length += AgentData.Length; + length += RegionInfo.Length; + length += RegionInfo2.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -22758,6 +26164,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -22943,7 +26353,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RegionInfo.Length;; + length += AgentData.Length; + length += RegionInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -22954,6 +26365,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -23055,7 +26470,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += RegionData.Length;; + length += RegionData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -23065,6 +26480,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -23394,7 +26813,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += RegionInfo.Length; length += RegionInfo2.Length; length += RegionInfo3.Length;; + length += RegionInfo.Length; + length += RegionInfo2.Length; + length += RegionInfo3.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -23406,6 +26827,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -23554,7 +26979,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RegionInfo.Length;; + length += AgentData.Length; + length += RegionInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -23565,6 +26991,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -23681,7 +27111,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TimeInfo.Length;; + length += TimeInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -23691,6 +27121,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -23799,7 +27233,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += SimulatorInfo.Length;; + length += SimulatorInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -23809,6 +27243,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -23867,7 +27305,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -23876,6 +27313,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -24007,7 +27448,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TransferInfo.Length;; + length += TransferInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -24017,6 +27458,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -24151,7 +27596,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TransferInfo.Length;; + length += TransferInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -24161,6 +27606,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -24266,7 +27715,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TransferInfo.Length;; + length += TransferInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -24276,6 +27725,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -24413,7 +27866,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += XferID.Length;; + length += XferID.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -24423,6 +27876,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -24527,7 +27984,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += XferID.Length;; + length += XferID.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -24537,6 +27994,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -24758,7 +28219,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Sender.Length; length += ObjectData.Length;; + length += Sender.Length; + length += ObjectData.Length; length++; for (int j = 0; j < VisualParam.Length; j++) { length += VisualParam[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -24773,6 +28235,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Sender.Length; + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Sender.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int VisualParamStart = 0; + while ( + VisualParamStart < VisualParam.Length) + { + int variableLength = 0; + int VisualParamCount = 0; + + i = VisualParamStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < VisualParam.Length) { + int blockLength = VisualParam[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++VisualParamCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)VisualParamCount; + for (i = VisualParamStart; i < VisualParamStart + VisualParamCount; i++) { VisualParam[i].ToBytes(packet, ref length); } + VisualParamStart += VisualParamCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -24933,7 +28454,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ObjectData.Length;; + length += ObjectData.Length; length++; for (int j = 0; j < CameraProperty.Length; j++) { length += CameraProperty[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -24947,6 +28468,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int CameraPropertyStart = 0; + while ( + CameraPropertyStart < CameraProperty.Length) + { + int variableLength = 0; + int CameraPropertyCount = 0; + + i = CameraPropertyStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < CameraProperty.Length) { + int blockLength = CameraProperty[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++CameraPropertyCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)CameraPropertyCount; + for (i = CameraPropertyStart; i < CameraPropertyStart + CameraPropertyCount; i++) { CameraProperty[i].ToBytes(packet, ref length); } + CameraPropertyStart += CameraPropertyCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -25048,7 +28626,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ObjectData.Length;; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -25058,6 +28636,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -25159,7 +28741,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ObjectData.Length;; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -25169,6 +28751,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -25329,7 +28915,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ObjectData.Length;; + length += ObjectData.Length; length++; for (int j = 0; j < ButtonData.Length; j++) { length += ButtonData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -25343,6 +28929,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += ObjectData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + ObjectData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ButtonDataStart = 0; + while ( + ButtonDataStart < ButtonData.Length) + { + int variableLength = 0; + int ButtonDataCount = 0; + + i = ButtonDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ButtonData.Length) { + int blockLength = ButtonData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ButtonDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ButtonDataCount; + for (i = ButtonDataStart; i < ButtonDataStart + ButtonDataCount; i++) { ButtonData[i].ToBytes(packet, ref length); } + ButtonDataStart += ButtonDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -25514,7 +29157,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TargetBlock.Length; length += UserInfo.Length;; + length += TargetBlock.Length; + length += UserInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -25525,6 +29169,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -25629,7 +29277,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += UserInfo.Length;; + length += UserInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -25639,6 +29287,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -25769,7 +29421,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += UserInfo.Length;; + length += UserInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -25779,6 +29431,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -25929,7 +29585,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -25940,6 +29597,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -26090,7 +29751,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -26101,6 +29763,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -26208,7 +29874,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -26218,6 +29884,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -26463,7 +30133,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += PropertiesData.Length;; + length += AgentData.Length; + length += PropertiesData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -26474,6 +30145,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -26678,7 +30353,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += PropertiesData.Length;; + length += AgentData.Length; + length += PropertiesData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -26689,6 +30365,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -26938,7 +30618,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += NewGroupData.Length;; + length += AgentData.Length; + length += NewGroupData.Length; length++; for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -26953,6 +30634,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += NewGroupData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + NewGroupData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int GroupDataStart = 0; + while ( + GroupDataStart < GroupData.Length) + { + int variableLength = 0; + int GroupDataCount = 0; + + i = GroupDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < GroupData.Length) { + int blockLength = GroupData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++GroupDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)GroupDataCount; + for (i = GroupDataStart; i < GroupDataStart + GroupDataCount; i++) { GroupData[i].ToBytes(packet, ref length); } + GroupDataStart += GroupDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -27164,7 +30904,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += PropertiesData.Length;; + length += AgentData.Length; + length += PropertiesData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -27175,6 +30916,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -27379,7 +31124,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += PropertiesData.Length;; + length += AgentData.Length; + length += PropertiesData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -27390,6 +31136,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -27554,7 +31304,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -27565,6 +31316,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -27732,7 +31487,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -27743,6 +31499,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -27922,7 +31682,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -27936,6 +31696,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -28083,7 +31900,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += EventData.Length;; + length += AgentData.Length; + length += EventData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -28094,6 +31912,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -28361,7 +32183,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += EventData.Length;; + length += AgentData.Length; + length += EventData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -28372,6 +32195,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -28519,7 +32346,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += EventData.Length;; + length += AgentData.Length; + length += EventData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -28530,6 +32358,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -28677,7 +32509,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += EventData.Length;; + length += AgentData.Length; + length += EventData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -28688,6 +32521,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -28903,7 +32740,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += EventData.Length; length += QueryData.Length;; + length += AgentData.Length; + length += EventData.Length; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -28915,6 +32754,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -29168,7 +33011,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -29179,6 +33023,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -29384,7 +33232,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -29395,6 +33244,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -29542,7 +33395,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -29553,6 +33407,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -29703,7 +33561,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -29714,6 +33573,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -29857,7 +33720,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -29867,6 +33730,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -29987,7 +33854,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -30000,6 +33866,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -30251,7 +34172,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; length++; for (int j = 0; j < Buttons.Length; j++) { length += Buttons[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -30265,6 +34186,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Data.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Data.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ButtonsStart = 0; + while ( + ButtonsStart < Buttons.Length) + { + int variableLength = 0; + int ButtonsCount = 0; + + i = ButtonsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Buttons.Length) { + int blockLength = Buttons[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ButtonsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ButtonsCount; + for (i = ButtonsStart; i < ButtonsStart + ButtonsCount; i++) { Buttons[i].ToBytes(packet, ref length); } + ButtonsStart += ButtonsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -30438,7 +34416,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -30449,6 +34428,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -30553,7 +34536,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -30563,6 +34546,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -30713,7 +34700,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -30724,6 +34712,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -30884,7 +34876,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -30894,6 +34886,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -31034,7 +35030,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -31044,6 +35040,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -31166,7 +35166,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ParcelData.Length;; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -31176,6 +35176,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -31327,7 +35331,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -31338,6 +35343,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -31598,7 +35607,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -31609,6 +35619,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -31872,7 +35886,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; length++; for (int j = 0; j < TaskIDs.Length; j++) { length += TaskIDs[j].Length; } length++; @@ -31891,6 +35906,83 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ParcelData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ParcelData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int TaskIDsStart = 0; + int OwnerIDsStart = 0; + while ( + TaskIDsStart < TaskIDs.Length || + OwnerIDsStart < OwnerIDs.Length) + { + int variableLength = 0; + int TaskIDsCount = 0; + int OwnerIDsCount = 0; + + i = TaskIDsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < TaskIDs.Length) { + int blockLength = TaskIDs[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++TaskIDsCount; + } + else { break; } + ++i; + } + + i = OwnerIDsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < OwnerIDs.Length) { + int blockLength = OwnerIDs[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++OwnerIDsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)TaskIDsCount; + for (i = TaskIDsStart; i < TaskIDsStart + TaskIDsCount; i++) { TaskIDs[i].ToBytes(packet, ref length); } + TaskIDsStart += TaskIDsCount; + + packet[length++] = (byte)OwnerIDsCount; + for (i = OwnerIDsStart; i < OwnerIDsStart + OwnerIDsCount; i++) { OwnerIDs[i].ToBytes(packet, ref length); } + OwnerIDsStart += OwnerIDsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -32042,7 +36134,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -32053,6 +36146,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -32316,7 +36413,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; length++; for (int j = 0; j < TaskIDs.Length; j++) { length += TaskIDs[j].Length; } length++; @@ -32335,6 +36433,83 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ParcelData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ParcelData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int TaskIDsStart = 0; + int OwnerIDsStart = 0; + while ( + TaskIDsStart < TaskIDs.Length || + OwnerIDsStart < OwnerIDs.Length) + { + int variableLength = 0; + int TaskIDsCount = 0; + int OwnerIDsCount = 0; + + i = TaskIDsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < TaskIDs.Length) { + int blockLength = TaskIDs[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++TaskIDsCount; + } + else { break; } + ++i; + } + + i = OwnerIDsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < OwnerIDs.Length) { + int blockLength = OwnerIDs[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++OwnerIDsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)TaskIDsCount; + for (i = TaskIDsStart; i < TaskIDsStart + TaskIDsCount; i++) { TaskIDs[i].ToBytes(packet, ref length); } + TaskIDsStart += TaskIDsCount; + + packet[length++] = (byte)OwnerIDsCount; + for (i = OwnerIDsStart; i < OwnerIDsStart + OwnerIDsCount; i++) { OwnerIDs[i].ToBytes(packet, ref length); } + OwnerIDsStart += OwnerIDsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -32542,7 +36717,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; length++; for (int j = 0; j < ReturnIDs.Length; j++) { length += ReturnIDs[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -32557,6 +36733,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += ParcelData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + ParcelData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ReturnIDsStart = 0; + while ( + ReturnIDsStart < ReturnIDs.Length) + { + int variableLength = 0; + int ReturnIDsCount = 0; + + i = ReturnIDsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ReturnIDs.Length) { + int blockLength = ReturnIDs[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ReturnIDsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ReturnIDsCount; + for (i = ReturnIDsStart; i < ReturnIDsStart + ReturnIDsCount; i++) { ReturnIDs[i].ToBytes(packet, ref length); } + ReturnIDsStart += ReturnIDsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -32661,7 +36896,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -32671,6 +36906,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -32797,7 +37036,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -32807,6 +37046,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -32964,7 +37207,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += _Header.Length;; + length += _Header.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -32978,6 +37221,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += _Header.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + _Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -33125,7 +37425,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -33136,6 +37437,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -33286,7 +37591,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -33297,6 +37603,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -33444,7 +37754,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -33455,6 +37766,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -33674,7 +37989,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; length++; for (int j = 0; j < ParcelData.Length; j++) { length += ParcelData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -33689,6 +38005,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += Data.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + Data.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ParcelDataStart = 0; + while ( + ParcelDataStart < ParcelData.Length) + { + int variableLength = 0; + int ParcelDataCount = 0; + + i = ParcelDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ParcelData.Length) { + int blockLength = ParcelData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ParcelDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ParcelDataCount; + for (i = ParcelDataStart; i < ParcelDataStart + ParcelDataCount; i++) { ParcelData[i].ToBytes(packet, ref length); } + ParcelDataStart += ParcelDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -33845,7 +38220,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -33856,6 +38232,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -34012,7 +38392,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -34023,6 +38404,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -34170,7 +38555,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -34181,6 +38567,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -34387,7 +38777,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += Data.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -34399,6 +38791,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -34550,7 +38946,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -34561,6 +38958,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -34715,7 +39116,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -34726,6 +39128,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -34899,7 +39305,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Data.Length;; + length += Data.Length; length++; for (int j = 0; j < List.Length; j++) { length += List[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -34913,6 +39319,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Data.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Data.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ListStart = 0; + while ( + ListStart < List.Length) + { + int variableLength = 0; + int ListCount = 0; + + i = ListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < List.Length) { + int blockLength = List[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ListCount; + for (i = ListStart; i < ListStart + ListCount; i++) { List[i].ToBytes(packet, ref length); } + ListStart += ListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -35135,7 +39598,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; length++; for (int j = 0; j < List.Length; j++) { length += List[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -35150,6 +39614,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += Data.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + Data.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ListStart = 0; + while ( + ListStart < List.Length) + { + int variableLength = 0; + int ListCount = 0; + + i = ListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < List.Length) { + int blockLength = List[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ListCount; + for (i = ListStart; i < ListStart + ListCount; i++) { List[i].ToBytes(packet, ref length); } + ListStart += ListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -35300,7 +39823,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -35311,6 +39835,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -35461,7 +39989,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -35472,6 +40001,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -35619,7 +40152,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -35630,6 +40164,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -35780,7 +40318,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -35791,6 +40330,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -35905,7 +40448,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -35918,6 +40460,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int UUIDNameBlockStart = 0; + while ( + UUIDNameBlockStart < UUIDNameBlock.Length) + { + int variableLength = 0; + int UUIDNameBlockCount = 0; + + i = UUIDNameBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < UUIDNameBlock.Length) { + int blockLength = UUIDNameBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++UUIDNameBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)UUIDNameBlockCount; + for (i = UUIDNameBlockStart; i < UUIDNameBlockStart + UUIDNameBlockCount; i++) { UUIDNameBlock[i].ToBytes(packet, ref length); } + UUIDNameBlockStart += UUIDNameBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -36068,7 +40665,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -36081,6 +40677,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int UUIDNameBlockStart = 0; + while ( + UUIDNameBlockStart < UUIDNameBlock.Length) + { + int variableLength = 0; + int UUIDNameBlockCount = 0; + + i = UUIDNameBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < UUIDNameBlock.Length) { + int blockLength = UUIDNameBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++UUIDNameBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)UUIDNameBlockCount; + for (i = UUIDNameBlockStart; i < UUIDNameBlockStart + UUIDNameBlockCount; i++) { UUIDNameBlock[i].ToBytes(packet, ref length); } + UUIDNameBlockStart += UUIDNameBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -36195,7 +40846,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -36208,6 +40858,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int UUIDNameBlockStart = 0; + while ( + UUIDNameBlockStart < UUIDNameBlock.Length) + { + int variableLength = 0; + int UUIDNameBlockCount = 0; + + i = UUIDNameBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < UUIDNameBlock.Length) { + int blockLength = UUIDNameBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++UUIDNameBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)UUIDNameBlockCount; + for (i = UUIDNameBlockStart; i < UUIDNameBlockStart + UUIDNameBlockCount; i++) { UUIDNameBlock[i].ToBytes(packet, ref length); } + UUIDNameBlockStart += UUIDNameBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -36341,7 +41046,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < UUIDNameBlock.Length; j++) { length += UUIDNameBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -36354,6 +41058,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int UUIDNameBlockStart = 0; + while ( + UUIDNameBlockStart < UUIDNameBlock.Length) + { + int variableLength = 0; + int UUIDNameBlockCount = 0; + + i = UUIDNameBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < UUIDNameBlock.Length) { + int blockLength = UUIDNameBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++UUIDNameBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)UUIDNameBlockCount; + for (i = UUIDNameBlockStart; i < UUIDNameBlockStart + UUIDNameBlockCount; i++) { UUIDNameBlock[i].ToBytes(packet, ref length); } + UUIDNameBlockStart += UUIDNameBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -36459,7 +41218,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -36469,6 +41228,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -36573,7 +41336,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -36583,6 +41346,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -36687,7 +41454,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Script.Length;; + length += Script.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -36697,6 +41464,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -36804,7 +41575,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Script.Length;; + length += Script.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -36814,6 +41585,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -36967,7 +41742,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Script.Length;; + length += AgentData.Length; + length += Script.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -36978,6 +41754,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -37128,7 +41908,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Script.Length;; + length += AgentData.Length; + length += Script.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -37139,6 +41920,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -37287,7 +42072,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Requester.Length;; + length += Requester.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -37297,6 +42082,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -37495,7 +42284,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += Requester.Length;; + length += Requester.Length; length++; for (int j = 0; j < SensedData.Length; j++) { length += SensedData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -37509,6 +42298,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Requester.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Requester.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int SensedDataStart = 0; + while ( + SensedDataStart < SensedData.Length) + { + int variableLength = 0; + int SensedDataCount = 0; + + i = SensedDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < SensedData.Length) { + int blockLength = SensedData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++SensedDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)SensedDataCount; + for (i = SensedDataStart; i < SensedDataStart + SensedDataCount; i++) { SensedData[i].ToBytes(packet, ref length); } + SensedDataStart += SensedDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -37616,7 +42462,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -37626,6 +42472,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -37842,7 +42692,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length; length += SimData.Length;; + length += AgentData.Length; + length += Data.Length; + length += SimData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -37854,6 +42706,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -37958,7 +42814,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -37968,6 +42824,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -38129,7 +42989,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -38143,6 +43003,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -38370,7 +43287,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MessageBlock.Length;; + length += AgentData.Length; + length += MessageBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -38381,6 +43299,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -38485,7 +43407,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -38495,6 +43417,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -38661,7 +43587,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentBlock.Length;; + length += AgentBlock.Length; length++; for (int j = 0; j < LocationBlock.Length; j++) { length += LocationBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -38675,6 +43601,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentBlock.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentBlock.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int LocationBlockStart = 0; + while ( + LocationBlockStart < LocationBlock.Length) + { + int variableLength = 0; + int LocationBlockCount = 0; + + i = LocationBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < LocationBlock.Length) { + int blockLength = LocationBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++LocationBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)LocationBlockCount; + for (i = LocationBlockStart; i < LocationBlockStart + LocationBlockCount; i++) { LocationBlock[i].ToBytes(packet, ref length); } + LocationBlockStart += LocationBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -38825,7 +43808,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RequestBlock.Length;; + length += AgentData.Length; + length += RequestBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -38836,6 +43820,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -38986,7 +43974,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GrantData.Length;; + length += AgentData.Length; + length += GrantData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -38997,6 +43986,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -39239,7 +44232,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MethodData.Length;; + length += AgentData.Length; + length += MethodData.Length; length++; for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -39254,6 +44248,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += MethodData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + MethodData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ParamListStart = 0; + while ( + ParamListStart < ParamList.Length) + { + int variableLength = 0; + int ParamListCount = 0; + + i = ParamListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ParamList.Length) { + int blockLength = ParamList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ParamListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ParamListCount; + for (i = ParamListStart; i < ParamListStart + ParamListCount; i++) { ParamList[i].ToBytes(packet, ref length); } + ParamListStart += ParamListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -39496,7 +44549,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MethodData.Length;; + length += AgentData.Length; + length += MethodData.Length; length++; for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -39511,6 +44565,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += MethodData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + MethodData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ParamListStart = 0; + while ( + ParamListStart < ParamList.Length) + { + int variableLength = 0; + int ParamListCount = 0; + + i = ParamListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ParamList.Length) { + int blockLength = ParamList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ParamListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ParamListCount; + for (i = ParamListStart; i < ParamListStart + ParamListCount; i++) { ParamList[i].ToBytes(packet, ref length); } + ParamListStart += ParamListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -39753,7 +44866,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MethodData.Length;; + length += AgentData.Length; + length += MethodData.Length; length++; for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -39768,6 +44882,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += MethodData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + MethodData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ParamListStart = 0; + while ( + ParamListStart < ParamList.Length) + { + int variableLength = 0; + int ParamListCount = 0; + + i = ParamListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ParamList.Length) { + int blockLength = ParamList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ParamListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ParamListCount; + for (i = ParamListStart; i < ParamListStart + ParamListCount; i++) { ParamList[i].ToBytes(packet, ref length); } + ParamListStart += ParamListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -39915,7 +45088,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MuteData.Length;; + length += AgentData.Length; + length += MuteData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -39926,6 +45100,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -40098,7 +45276,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MuteData.Length;; + length += AgentData.Length; + length += MuteData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -40109,6 +45288,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -40275,7 +45458,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MuteData.Length;; + length += AgentData.Length; + length += MuteData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -40286,6 +45470,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -40496,7 +45684,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += NotecardData.Length;; + length += AgentData.Length; + length += NotecardData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -40511,6 +45700,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += NotecardData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + NotecardData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -40768,7 +46016,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -40782,6 +46030,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -41039,7 +46344,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -41053,6 +46358,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -41239,7 +46601,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -41253,6 +46615,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -41442,7 +46861,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -41456,6 +46875,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -41616,7 +47092,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -41630,6 +47106,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -41793,7 +47326,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -41807,6 +47340,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -41954,7 +47544,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -41965,6 +47556,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -42137,7 +47732,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += FolderData.Length;; + length += AgentData.Length; + length += FolderData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -42148,6 +47744,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -42333,7 +47933,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -42347,6 +47947,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int FolderDataStart = 0; + while ( + FolderDataStart < FolderData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -42514,7 +48171,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -42528,6 +48185,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -42688,7 +48402,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -42702,6 +48416,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int FolderDataStart = 0; + while ( + FolderDataStart < FolderData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -42862,7 +48633,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -42873,6 +48645,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -43214,7 +48990,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } length++; @@ -43232,6 +49008,81 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int FolderDataStart = 0; + int ItemDataStart = 0; + while ( + FolderDataStart < FolderData.Length || + ItemDataStart < ItemData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + int ItemDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + i = ItemDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ItemData.Length) { + int blockLength = ItemData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ItemDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + packet[length++] = (byte)ItemDataCount; + for (i = ItemDataStart; i < ItemDataStart + ItemDataCount; i++) { ItemData[i].ToBytes(packet, ref length); } + ItemDataStart += ItemDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -43396,7 +49247,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -43410,6 +49261,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -43658,7 +49566,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < InventoryData.Length; j++) { length += InventoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -43672,6 +49580,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -44007,7 +49972,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } length++; @@ -44025,6 +49990,81 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int FolderDataStart = 0; + int ItemDataStart = 0; + while ( + FolderDataStart < FolderData.Length || + ItemDataStart < ItemData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + int ItemDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + i = ItemDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ItemData.Length) { + int blockLength = ItemData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ItemDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + packet[length++] = (byte)ItemDataCount; + for (i = ItemDataStart; i < ItemDataStart + ItemDataCount; i++) { ItemData[i].ToBytes(packet, ref length); } + ItemDataStart += ItemDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -44135,7 +50175,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += QueryData.Length;; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -44145,6 +50185,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -44252,7 +50296,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += QueryData.Length;; + length += QueryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -44262,6 +50306,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -44478,7 +50526,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } length++; @@ -44496,6 +50544,81 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int FolderDataStart = 0; + int ItemDataStart = 0; + while ( + FolderDataStart < FolderData.Length || + ItemDataStart < ItemData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + int ItemDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + i = ItemDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ItemData.Length) { + int blockLength = ItemData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ItemDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + packet[length++] = (byte)ItemDataCount; + for (i = ItemDataStart; i < ItemDataStart + ItemDataCount; i++) { ItemData[i].ToBytes(packet, ref length); } + ItemDataStart += ItemDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -44644,7 +50767,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -44655,6 +50779,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -44939,7 +51067,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += UpdateData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += UpdateData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -44951,6 +51081,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -45102,7 +51236,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -45113,6 +51248,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -45266,7 +51405,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -45277,6 +51417,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -45424,7 +51568,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -45435,6 +51580,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -45560,7 +51709,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += InventoryData.Length;; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -45570,6 +51719,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -45789,7 +51942,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += AgentBlock.Length;; + length += AgentData.Length; + length += AgentBlock.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -45804,6 +51958,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += AgentBlock.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + AgentBlock.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -45908,7 +52121,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TransactionData.Length;; + length += TransactionData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -45918,6 +52131,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -46235,7 +52452,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RezData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += RezData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -46247,6 +52466,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -46533,7 +52756,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RezData.Length; length += NotecardData.Length;; + 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 != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -46549,6 +52774,67 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += RezData.Length; + fixedLength += NotecardData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + RezData.ToBytes(fixedBytes, ref i); + NotecardData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InventoryDataStart = 0; + while ( + InventoryDataStart < InventoryData.Length) + { + int variableLength = 0; + int InventoryDataCount = 0; + + i = InventoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InventoryData.Length) { + int blockLength = InventoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InventoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InventoryDataCount; + for (i = InventoryDataStart; i < InventoryDataStart + InventoryDataCount; i++) { InventoryData[i].ToBytes(packet, ref length); } + InventoryDataStart += InventoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -46752,7 +53038,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionBlock.Length;; + length += AgentData.Length; + length += TransactionBlock.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -46767,6 +53054,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += TransactionBlock.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + TransactionBlock.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int FolderDataStart = 0; + while ( + FolderDataStart < FolderData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -46914,7 +53260,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionBlock.Length;; + length += AgentData.Length; + length += TransactionBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -46925,6 +53272,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -47029,7 +53380,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentBlock.Length;; + length += AgentBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -47039,6 +53390,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -47186,7 +53541,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ExBlock.Length;; + length += AgentData.Length; + length += ExBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -47197,6 +53553,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -47347,7 +53707,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += AgentBlock.Length;; + length += AgentData.Length; + length += AgentBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -47358,6 +53719,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -47561,7 +53926,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionBlock.Length;; + length += AgentData.Length; + length += TransactionBlock.Length; length++; for (int j = 0; j < FolderData.Length; j++) { length += FolderData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -47576,6 +53942,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += TransactionBlock.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + TransactionBlock.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int FolderDataStart = 0; + while ( + FolderDataStart < FolderData.Length) + { + int variableLength = 0; + int FolderDataCount = 0; + + i = FolderDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < FolderData.Length) { + int blockLength = FolderData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++FolderDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)FolderDataCount; + for (i = FolderDataStart; i < FolderDataStart + FolderDataCount; i++) { FolderData[i].ToBytes(packet, ref length); } + FolderDataStart += FolderDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -47723,7 +54148,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionBlock.Length;; + length += AgentData.Length; + length += TransactionBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -47734,6 +54160,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -48021,7 +54451,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += UpdateBlock.Length; length += InventoryBlock.Length;; + length += AgentData.Length; + length += UpdateBlock.Length; + length += InventoryBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -48033,6 +54465,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -48235,7 +54671,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryBlock.Length;; + length += AgentData.Length; + length += InventoryBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -48246,6 +54683,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -48456,7 +54897,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += EventData.Length; length += InventoryBlock.Length;; + length += AgentData.Length; + length += EventData.Length; + length += InventoryBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -48468,6 +54911,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -48569,7 +55016,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += RequestBlock.Length;; + length += RequestBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -48579,6 +55026,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -48683,7 +55134,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ReplyBlock.Length;; + length += ReplyBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -48693,6 +55144,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -48878,7 +55333,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -48889,6 +55345,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -49037,7 +55497,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -49048,6 +55509,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -49184,7 +55649,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += MoneyData.Length;; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -49194,6 +55659,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -49377,7 +55846,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += TargetBlock.Length; length += MoneyData.Length;; + length += TargetBlock.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -49388,6 +55858,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -49557,7 +56031,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -49571,6 +56045,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -49737,7 +56268,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -49751,6 +56282,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -49871,7 +56459,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += MuteData.Length;; + length += MuteData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -49881,6 +56469,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -49982,7 +56574,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -49992,6 +56584,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -50155,7 +56751,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Rights.Length; j++) { length += Rights[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -50169,6 +56765,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int RightsStart = 0; + while ( + RightsStart < Rights.Length) + { + int variableLength = 0; + int RightsCount = 0; + + i = RightsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Rights.Length) { + int blockLength = Rights[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++RightsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)RightsCount; + for (i = RightsStart; i < RightsStart + RightsCount; i++) { Rights[i].ToBytes(packet, ref length); } + RightsStart += RightsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -50329,7 +56982,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Rights.Length; j++) { length += Rights[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -50343,6 +56996,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int RightsStart = 0; + while ( + RightsStart < Rights.Length) + { + int variableLength = 0; + int RightsCount = 0; + + i = RightsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Rights.Length) { + int blockLength = Rights[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++RightsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)RightsCount; + for (i = RightsStart; i < RightsStart + RightsCount; i++) { Rights[i].ToBytes(packet, ref length); } + RightsStart += RightsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -50457,7 +57167,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < AgentBlock.Length; j++) { length += AgentBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -50470,6 +57179,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int AgentBlockStart = 0; + while ( + AgentBlockStart < AgentBlock.Length) + { + int variableLength = 0; + int AgentBlockCount = 0; + + i = AgentBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AgentBlock.Length) { + int blockLength = AgentBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AgentBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AgentBlockCount; + for (i = AgentBlockStart; i < AgentBlockStart + AgentBlockCount; i++) { AgentBlock[i].ToBytes(packet, ref length); } + AgentBlockStart += AgentBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -50584,7 +57348,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < AgentBlock.Length; j++) { length += AgentBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -50597,6 +57360,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int AgentBlockStart = 0; + while ( + AgentBlockStart < AgentBlock.Length) + { + int variableLength = 0; + int AgentBlockCount = 0; + + i = AgentBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AgentBlock.Length) { + int blockLength = AgentBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AgentBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AgentBlockCount; + for (i = AgentBlockStart; i < AgentBlockStart + AgentBlockCount; i++) { AgentBlock[i].ToBytes(packet, ref length); } + AgentBlockStart += AgentBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -50770,7 +57588,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += StartLocationData.Length;; + length += AgentData.Length; + length += StartLocationData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -50781,6 +57600,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -50911,7 +57734,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AssetBlock.Length;; + length += AssetBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -50921,6 +57744,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -51028,7 +57855,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AssetBlock.Length;; + length += AssetBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -51038,6 +57865,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -51238,7 +58069,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -51249,6 +58081,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -51415,7 +58251,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ReplyData.Length;; + length += AgentData.Length; + length += ReplyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -51426,6 +58263,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -51612,7 +58453,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -51623,6 +58465,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -51792,7 +58638,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < RoleChange.Length; j++) { length += RoleChange[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -51806,6 +58652,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int RoleChangeStart = 0; + while ( + RoleChangeStart < RoleChange.Length) + { + int variableLength = 0; + int RoleChangeCount = 0; + + i = RoleChangeStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < RoleChange.Length) { + int blockLength = RoleChange[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++RoleChangeCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)RoleChangeCount; + for (i = RoleChangeStart; i < RoleChangeStart + RoleChangeCount; i++) { RoleChange[i].ToBytes(packet, ref length); } + RoleChangeStart += RoleChangeCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -51954,7 +58857,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -51965,6 +58869,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -52112,7 +59020,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -52123,6 +59032,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -52326,7 +59239,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; length++; for (int j = 0; j < EjectData.Length; j++) { length += EjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -52341,6 +59255,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += GroupData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + GroupData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int EjectDataStart = 0; + while ( + EjectDataStart < EjectData.Length) + { + int variableLength = 0; + int EjectDataCount = 0; + + i = EjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < EjectData.Length) { + int blockLength = EjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++EjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)EjectDataCount; + for (i = EjectDataStart; i < EjectDataStart + EjectDataCount; i++) { EjectData[i].ToBytes(packet, ref length); } + EjectDataStart += EjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -52528,7 +59501,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length; length += EjectData.Length;; + length += AgentData.Length; + length += GroupData.Length; + length += EjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -52540,6 +59515,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -52687,7 +59666,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -52698,6 +59678,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -52845,7 +59829,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -52856,6 +59841,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -53062,7 +60051,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; length++; for (int j = 0; j < InviteData.Length; j++) { length += InviteData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -53077,6 +60067,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += GroupData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + GroupData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int InviteDataStart = 0; + while ( + InviteDataStart < InviteData.Length) + { + int variableLength = 0; + int InviteDataCount = 0; + + i = InviteDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < InviteData.Length) { + int blockLength = InviteData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++InviteDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)InviteDataCount; + for (i = InviteDataStart; i < InviteDataStart + InviteDataCount; i++) { InviteData[i].ToBytes(packet, ref length); } + InviteDataStart += InviteDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -53224,7 +60273,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -53235,6 +60285,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -53470,7 +60524,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -53481,6 +60536,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -53638,7 +60697,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -53649,6 +60709,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -53898,7 +60962,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -53909,6 +60974,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -54066,7 +61135,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -54077,6 +61147,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -54325,7 +61399,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; length++; for (int j = 0; j < HistoryData.Length; j++) { length += HistoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -54340,6 +61415,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += MoneyData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + MoneyData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int HistoryDataStart = 0; + while ( + HistoryDataStart < HistoryData.Length) + { + int variableLength = 0; + int HistoryDataCount = 0; + + i = HistoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < HistoryData.Length) { + int blockLength = HistoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++HistoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)HistoryDataCount; + for (i = HistoryDataStart; i < HistoryDataStart + HistoryDataCount; i++) { HistoryData[i].ToBytes(packet, ref length); } + HistoryDataStart += HistoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -54497,7 +61631,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -54508,6 +61643,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -54793,7 +61932,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += MoneyData.Length;; + length += AgentData.Length; + length += MoneyData.Length; length++; for (int j = 0; j < HistoryData.Length; j++) { length += HistoryData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -54808,6 +61948,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += MoneyData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + MoneyData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int HistoryDataStart = 0; + while ( + HistoryDataStart < HistoryData.Length) + { + int variableLength = 0; + int HistoryDataCount = 0; + + i = HistoryDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < HistoryData.Length) { + int blockLength = HistoryData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++HistoryDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)HistoryDataCount; + for (i = HistoryDataStart; i < HistoryDataStart + HistoryDataCount; i++) { HistoryData[i].ToBytes(packet, ref length); } + HistoryDataStart += HistoryDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -54998,7 +62197,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length; length += TransactionData.Length;; + length += AgentData.Length; + length += GroupData.Length; + length += TransactionData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -55010,6 +62211,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -55316,7 +62521,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionData.Length;; + length += AgentData.Length; + length += TransactionData.Length; length++; for (int j = 0; j < ProposalData.Length; j++) { length += ProposalData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -55331,6 +62537,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += TransactionData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + TransactionData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ProposalDataStart = 0; + while ( + ProposalDataStart < ProposalData.Length) + { + int variableLength = 0; + int ProposalDataCount = 0; + + i = ProposalDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ProposalData.Length) { + int blockLength = ProposalData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ProposalDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ProposalDataCount; + for (i = ProposalDataStart; i < ProposalDataStart + ProposalDataCount; i++) { ProposalData[i].ToBytes(packet, ref length); } + ProposalDataStart += ProposalDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -55521,7 +62786,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length; length += TransactionData.Length;; + length += AgentData.Length; + length += GroupData.Length; + length += TransactionData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -55533,6 +62800,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -55919,7 +63190,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += TransactionData.Length; length += HistoryItemData.Length;; + 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 != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -55935,6 +63208,67 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += TransactionData.Length; + fixedLength += HistoryItemData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + TransactionData.ToBytes(fixedBytes, ref i); + HistoryItemData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int VoteItemStart = 0; + while ( + VoteItemStart < VoteItem.Length) + { + int variableLength = 0; + int VoteItemCount = 0; + + i = VoteItemStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < VoteItem.Length) { + int blockLength = VoteItem[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++VoteItemCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)VoteItemCount; + for (i = VoteItemStart; i < VoteItemStart + VoteItemCount; i++) { VoteItem[i].ToBytes(packet, ref length); } + VoteItemStart += VoteItemCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -56111,7 +63445,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ProposalData.Length;; + length += AgentData.Length; + length += ProposalData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -56122,6 +63457,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -56291,7 +63630,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ProposalData.Length;; + length += AgentData.Length; + length += ProposalData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -56302,6 +63642,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -56452,7 +63796,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -56463,6 +63808,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -56715,7 +64064,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; length++; for (int j = 0; j < MemberData.Length; j++) { length += MemberData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -56730,6 +64080,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += GroupData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + GroupData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int MemberDataStart = 0; + while ( + MemberDataStart < MemberData.Length) + { + int variableLength = 0; + int MemberDataCount = 0; + + i = MemberDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < MemberData.Length) { + int blockLength = MemberData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++MemberDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)MemberDataCount; + for (i = MemberDataStart; i < MemberDataStart + MemberDataCount; i++) { MemberData[i].ToBytes(packet, ref length); } + MemberDataStart += MemberDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -56838,7 +64247,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -56848,6 +64257,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -56998,7 +64411,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -57009,6 +64423,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -57202,7 +64620,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length; length += NewData.Length;; + length += AgentData.Length; + length += Data.Length; + length += NewData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -57214,6 +64634,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -57364,7 +64788,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -57375,6 +64800,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -57640,7 +65069,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; length++; for (int j = 0; j < RoleData.Length; j++) { length += RoleData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -57655,6 +65085,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += GroupData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + GroupData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int RoleDataStart = 0; + while ( + RoleDataStart < RoleData.Length) + { + int variableLength = 0; + int RoleDataCount = 0; + + i = RoleDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < RoleData.Length) { + int blockLength = RoleData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++RoleDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)RoleDataCount; + for (i = RoleDataStart; i < RoleDataStart + RoleDataCount; i++) { RoleData[i].ToBytes(packet, ref length); } + RoleDataStart += RoleDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -57805,7 +65294,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += GroupData.Length;; + length += AgentData.Length; + length += GroupData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -57816,6 +65306,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -57985,7 +65479,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < MemberData.Length; j++) { length += MemberData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -57999,6 +65493,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int MemberDataStart = 0; + while ( + MemberDataStart < MemberData.Length) + { + int variableLength = 0; + int MemberDataCount = 0; + + i = MemberDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < MemberData.Length) { + int blockLength = MemberData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++MemberDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)MemberDataCount; + for (i = MemberDataStart; i < MemberDataStart + MemberDataCount; i++) { MemberData[i].ToBytes(packet, ref length); } + MemberDataStart += MemberDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -58109,7 +65660,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -58119,6 +65670,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -58305,7 +65860,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -58319,6 +65874,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int GroupDataStart = 0; + while ( + GroupDataStart < GroupData.Length) + { + int variableLength = 0; + int GroupDataCount = 0; + + i = GroupDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < GroupData.Length) { + int blockLength = GroupData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++GroupDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)GroupDataCount; + for (i = GroupDataStart; i < GroupDataStart + GroupDataCount; i++) { GroupData[i].ToBytes(packet, ref length); } + GroupDataStart += GroupDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -58429,7 +66041,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -58439,6 +66051,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -58661,7 +66277,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < RoleData.Length; j++) { length += RoleData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -58675,6 +66291,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int RoleDataStart = 0; + while ( + RoleDataStart < RoleData.Length) + { + int variableLength = 0; + int RoleDataCount = 0; + + i = RoleDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < RoleData.Length) { + int blockLength = RoleData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++RoleDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)RoleDataCount; + for (i = RoleDataStart; i < RoleDataStart + RoleDataCount; i++) { RoleData[i].ToBytes(packet, ref length); } + RoleDataStart += RoleDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -58779,7 +66452,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += RequestData.Length;; + length += RequestData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -58789,6 +66462,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -58912,7 +66589,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ReplyData.Length;; + length += ReplyData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -58922,6 +66599,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -59026,7 +66707,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -59036,6 +66717,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -59206,7 +66891,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -59220,6 +66905,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int WearableDataStart = 0; + while ( + WearableDataStart < WearableData.Length) + { + int variableLength = 0; + int WearableDataCount = 0; + + i = WearableDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < WearableData.Length) { + int blockLength = WearableData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++WearableDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)WearableDataCount; + for (i = WearableDataStart; i < WearableDataStart + WearableDataCount; i++) { WearableData[i].ToBytes(packet, ref length); } + WearableDataStart += WearableDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -59384,7 +67126,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -59398,6 +67140,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int WearableDataStart = 0; + while ( + WearableDataStart < WearableData.Length) + { + int variableLength = 0; + int WearableDataCount = 0; + + i = WearableDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < WearableData.Length) { + int blockLength = WearableData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++WearableDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)WearableDataCount; + for (i = WearableDataStart; i < WearableDataStart + WearableDataCount; i++) { WearableData[i].ToBytes(packet, ref length); } + WearableDataStart += WearableDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -59564,7 +67363,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -59578,6 +67377,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int WearableDataStart = 0; + while ( + WearableDataStart < WearableData.Length) + { + int variableLength = 0; + int WearableDataCount = 0; + + i = WearableDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < WearableData.Length) { + int blockLength = WearableData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++WearableDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)WearableDataCount; + for (i = WearableDataStart; i < WearableDataStart + WearableDataCount; i++) { WearableData[i].ToBytes(packet, ref length); } + WearableDataStart += WearableDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -59763,7 +67619,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < WearableData.Length; j++) { length += WearableData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -59777,6 +67633,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int WearableDataStart = 0; + while ( + WearableDataStart < WearableData.Length) + { + int variableLength = 0; + int WearableDataCount = 0; + + i = WearableDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < WearableData.Length) { + int blockLength = WearableData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++WearableDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)WearableDataCount; + for (i = WearableDataStart; i < WearableDataStart + WearableDataCount; i++) { WearableData[i].ToBytes(packet, ref length); } + WearableDataStart += WearableDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -59881,7 +67794,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -59891,6 +67804,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -60069,7 +67986,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -60079,6 +67996,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -60219,7 +68140,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < AgentGroupData.Length; j++) { length += AgentGroupData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -60232,6 +68152,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int AgentGroupDataStart = 0; + while ( + AgentGroupDataStart < AgentGroupData.Length) + { + int variableLength = 0; + int AgentGroupDataCount = 0; + + i = AgentGroupDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AgentGroupData.Length) { + int blockLength = AgentGroupData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AgentGroupDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AgentGroupDataCount; + for (i = AgentGroupDataStart; i < AgentGroupDataStart + AgentGroupDataCount; i++) { AgentGroupData[i].ToBytes(packet, ref length); } + AgentGroupDataStart += AgentGroupDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -60421,7 +68396,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -60435,6 +68410,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int GroupDataStart = 0; + while ( + GroupDataStart < GroupData.Length) + { + int variableLength = 0; + int GroupDataCount = 0; + + i = GroupDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < GroupData.Length) { + int blockLength = GroupData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++GroupDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)GroupDataCount; + for (i = GroupDataStart; i < GroupDataStart + GroupDataCount; i++) { GroupData[i].ToBytes(packet, ref length); } + GroupDataStart += GroupDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -60540,7 +68572,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -60550,6 +68582,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -60655,7 +68691,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += DataBlock.Length;; + length += DataBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -60665,6 +68701,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -60766,7 +68806,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += DataBlock.Length;; + length += DataBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -60776,6 +68816,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -60834,7 +68878,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -60843,6 +68886,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -61045,7 +69092,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -61056,6 +69104,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -61320,7 +69372,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += HeaderData.Length;; + length += AgentData.Length; + length += HeaderData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -61335,6 +69388,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += HeaderData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + HeaderData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -61439,7 +69551,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += ObjectData.Length;; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -61449,6 +69561,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -61655,7 +69771,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += HeaderData.Length;; + length += AgentData.Length; + length += HeaderData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -61670,6 +69787,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += HeaderData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + HeaderData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -61774,7 +69950,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -61784,6 +69960,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -61965,7 +70145,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += UserData.Length;; + length += AgentData.Length; + length += UserData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -61976,6 +70157,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -62142,7 +70327,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += UserData.Length;; + length += AgentData.Length; + length += UserData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -62153,6 +70339,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -62330,7 +70520,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += FileData.Length;; + length += AgentData.Length; + length += FileData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -62341,6 +70532,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -62538,7 +70733,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += MethodData.Length;; + length += MethodData.Length; length++; for (int j = 0; j < ParamList.Length; j++) { length += ParamList[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -62552,6 +70747,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += MethodData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + MethodData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ParamListStart = 0; + while ( + ParamListStart < ParamList.Length) + { + int variableLength = 0; + int ParamListCount = 0; + + i = ParamListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ParamList.Length) { + int blockLength = ParamList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ParamListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ParamListCount; + for (i = ParamListStart; i < ParamListStart + ParamListCount; i++) { ParamList[i].ToBytes(packet, ref length); } + ParamListStart += ParamListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -62665,7 +70917,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -62675,6 +70927,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -62847,7 +71103,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < LayerData.Length; j++) { length += LayerData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -62861,6 +71117,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int LayerDataStart = 0; + while ( + LayerDataStart < LayerData.Length) + { + int variableLength = 0; + int LayerDataCount = 0; + + i = LayerDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < LayerData.Length) { + int blockLength = LayerData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++LayerDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)LayerDataCount; + for (i = LayerDataStart; i < LayerDataStart + LayerDataCount; i++) { LayerData[i].ToBytes(packet, ref length); } + LayerDataStart += LayerDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -63030,7 +71343,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += PositionData.Length;; + length += AgentData.Length; + length += PositionData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -63041,6 +71355,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -63213,7 +71531,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += NameData.Length;; + length += AgentData.Length; + length += NameData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -63224,6 +71543,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -63423,7 +71746,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -63437,6 +71760,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -63596,7 +71976,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RequestData.Length;; + length += AgentData.Length; + length += RequestData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -63607,6 +71988,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -63841,7 +72226,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RequestData.Length;; + length += AgentData.Length; + length += RequestData.Length; length++; for (int j = 0; j < Data.Length; j++) { length += Data[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -63856,6 +72242,65 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + fixedLength += RequestData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + RequestData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataStart = 0; + while ( + DataStart < Data.Length) + { + int variableLength = 0; + int DataCount = 0; + + i = DataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Data.Length) { + int blockLength = Data[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataCount; + for (i = DataStart; i < DataStart + DataCount; i++) { Data[i].ToBytes(packet, ref length); } + DataStart += DataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -64060,7 +72505,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -64070,6 +72515,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -64177,7 +72626,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += CommandBlock.Length;; + length += CommandBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -64187,6 +72636,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -64395,7 +72848,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += DataBlock.Length; length += DataBlockExtended.Length;; + length += DataBlock.Length; + length += DataBlockExtended.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -64406,6 +72860,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -64578,7 +73036,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += RequestData.Length;; + length += AgentData.Length; + length += RequestData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -64589,6 +73048,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -64803,7 +73266,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += RequestData.Length;; + length += RequestData.Length; length++; for (int j = 0; j < ReportData.Length; j++) { length += ReportData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -64817,6 +73280,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += RequestData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + RequestData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ReportDataStart = 0; + while ( + ReportDataStart < ReportData.Length) + { + int variableLength = 0; + int ReportDataCount = 0; + + i = ReportDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ReportData.Length) { + int blockLength = ReportData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ReportDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ReportDataCount; + for (i = ReportDataStart; i < ReportDataStart + ReportDataCount; i++) { ReportData[i].ToBytes(packet, ref length); } + ReportDataStart += ReportDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -65037,7 +73557,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += Data.Length;; + length += AgentData.Length; + length += Data.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -65048,6 +73569,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -65211,7 +73736,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -65225,6 +73750,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -65462,7 +74044,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += AgentData.Length; length += InventoryData.Length;; + length += AgentData.Length; + length += InventoryData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -65473,6 +74056,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -65587,7 +74174,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; length++; for (int j = 0; j < Packets.Length; j++) { length += Packets[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -65600,6 +74186,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 10; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int PacketsStart = 0; + while ( + PacketsStart < Packets.Length) + { + int variableLength = 0; + int PacketsCount = 0; + + i = PacketsStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Packets.Length) { + int blockLength = Packets[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++PacketsCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)PacketsCount; + for (i = PacketsStart; i < PacketsStart + PacketsCount; i++) { Packets[i].ToBytes(packet, ref length); } + PacketsStart += PacketsCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -65705,7 +74346,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; - length += CircuitInfo.Length;; + length += CircuitInfo.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -65715,6 +74356,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -65773,7 +74418,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 10; -; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -65782,6 +74426,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -66022,7 +74670,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -66033,6 +74682,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -66216,7 +74869,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -66230,6 +74883,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -66394,7 +75104,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -66408,6 +75118,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -66572,7 +75339,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -66586,6 +75353,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -66737,7 +75561,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length; length += ObjectData.Length;; + length += AgentData.Length; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -66748,6 +75573,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -66972,7 +75801,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += Index.Length;; + length += Index.Length; length++; for (int j = 0; j < Location.Length; j++) { length += Location[j].Length; } length++; @@ -66990,6 +75819,81 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Index.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Index.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int LocationStart = 0; + int AgentDataStart = 0; + while ( + LocationStart < Location.Length || + AgentDataStart < AgentData.Length) + { + int variableLength = 0; + int LocationCount = 0; + int AgentDataCount = 0; + + i = LocationStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Location.Length) { + int blockLength = Location[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++LocationCount; + } + else { break; } + ++i; + } + + i = AgentDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AgentData.Length) { + int blockLength = AgentData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AgentDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)LocationCount; + for (i = LocationStart; i < LocationStart + LocationCount; i++) { Location[i].ToBytes(packet, ref length); } + LocationStart += LocationCount; + + packet[length++] = (byte)AgentDataCount; + for (i = AgentDataStart; i < AgentDataStart + AgentDataCount; i++) { AgentData[i].ToBytes(packet, ref length); } + AgentDataStart += AgentDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -67210,7 +76114,9 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length; length += RegionData.Length; length += Info.Length;; + length += AgentData.Length; + length += RegionData.Length; + length += Info.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -67222,6 +76128,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -67326,7 +76236,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -67336,6 +76246,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -67602,7 +76516,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; -; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -67615,6 +76528,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -67792,7 +76760,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += ObjectData.Length;; + length += ObjectData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -67802,6 +76770,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -67965,7 +76937,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length; length += ParcelData.Length;; + length += AgentData.Length; + length += ParcelData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -67976,6 +76949,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -68089,7 +77066,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += DataBlock.Length;; + length += DataBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -68099,6 +77076,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -68203,7 +77184,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += DataBlock.Length;; + length += DataBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -68213,6 +77194,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -68333,7 +77318,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; -; length++; for (int j = 0; j < DataBlock.Length; j++) { length += DataBlock[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -68346,6 +77330,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int DataBlockStart = 0; + while ( + DataBlockStart < DataBlock.Length) + { + int variableLength = 0; + int DataBlockCount = 0; + + i = DataBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < DataBlock.Length) { + int blockLength = DataBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++DataBlockCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)DataBlockCount; + for (i = DataBlockStart; i < DataBlockStart + DataBlockCount; i++) { DataBlock[i].ToBytes(packet, ref length); } + DataBlockStart += DataBlockCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -68539,7 +77578,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 8; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < Effect.Length; j++) { length += Effect[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -68553,6 +77592,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 8; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int EffectStart = 0; + while ( + EffectStart < Effect.Length) + { + int variableLength = 0; + int EffectCount = 0; + + i = EffectStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < Effect.Length) { + int blockLength = Effect[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++EffectCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)EffectCount; + for (i = EffectStart; i < EffectStart + EffectCount; i++) { Effect[i].ToBytes(packet, ref length); } + EffectStart += EffectCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -68657,7 +77753,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += PingID.Length;; + length += PingID.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -68667,6 +77763,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -68768,7 +77868,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += PingID.Length;; + length += PingID.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -68778,6 +77878,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -68913,7 +78017,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -68923,6 +78027,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -69158,7 +78266,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < AnimationList.Length; j++) { length += AnimationList[j].Length; } length++; @@ -69176,6 +78284,81 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 2; + + int AnimationListStart = 0; + int PhysicalAvatarEventListStart = 0; + while ( + AnimationListStart < AnimationList.Length || + PhysicalAvatarEventListStart < PhysicalAvatarEventList.Length) + { + int variableLength = 0; + int AnimationListCount = 0; + int PhysicalAvatarEventListCount = 0; + + i = AnimationListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AnimationList.Length) { + int blockLength = AnimationList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AnimationListCount; + } + else { break; } + ++i; + } + + i = PhysicalAvatarEventListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < PhysicalAvatarEventList.Length) { + int blockLength = PhysicalAvatarEventList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++PhysicalAvatarEventListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AnimationListCount; + for (i = AnimationListStart; i < AnimationListStart + AnimationListCount; i++) { AnimationList[i].ToBytes(packet, ref length); } + AnimationListStart += AnimationListCount; + + packet[length++] = (byte)PhysicalAvatarEventListCount; + for (i = PhysicalAvatarEventListStart; i < PhysicalAvatarEventListStart + PhysicalAvatarEventListCount; i++) { PhysicalAvatarEventList[i].ToBytes(packet, ref length); } + PhysicalAvatarEventListStart += PhysicalAvatarEventListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -69327,7 +78510,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length; length += TargetObject.Length;; + length += AgentData.Length; + length += TargetObject.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -69338,6 +78522,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -69442,7 +78630,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -69452,6 +78640,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -69624,7 +78816,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < RequestImage.Length; j++) { length += RequestImage[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -69638,6 +78830,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int RequestImageStart = 0; + while ( + RequestImageStart < RequestImage.Length) + { + int variableLength = 0; + int RequestImageCount = 0; + + i = RequestImageStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < RequestImage.Length) { + int blockLength = RequestImage[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++RequestImageCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)RequestImageCount; + for (i = RequestImageStart; i < RequestImageStart + RequestImageCount; i++) { RequestImage[i].ToBytes(packet, ref length); } + RequestImageStart += RequestImageCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -69809,7 +79058,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += ImageID.Length; length += ImageData.Length;; + length += ImageID.Length; + length += ImageData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -69820,6 +79070,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -69985,7 +79239,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += ImageID.Length; length += ImageData.Length;; + length += ImageID.Length; + length += ImageData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -69996,6 +79251,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -70157,7 +79416,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += LayerID.Length; length += LayerData.Length;; + length += LayerID.Length; + length += LayerData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -70168,6 +79428,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -70602,7 +79866,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += RegionData.Length;; + length += RegionData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -70616,6 +79880,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += RegionData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + RegionData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -70797,7 +80118,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += RegionData.Length;; + length += RegionData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -70811,6 +80132,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += RegionData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + RegionData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -70978,7 +80356,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += RegionData.Length;; + length += RegionData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -70992,6 +80370,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += RegionData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + RegionData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -71187,7 +80622,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += RegionData.Length;; + length += RegionData.Length; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -71201,6 +80636,63 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += RegionData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + RegionData.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -71315,7 +80807,6 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; -; length++; for (int j = 0; j < ObjectData.Length; j++) { length += ObjectData[j].Length; } if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } @@ -71328,6 +80819,61 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + fixedLength += 1; + + int ObjectDataStart = 0; + while ( + ObjectDataStart < ObjectData.Length) + { + int variableLength = 0; + int ObjectDataCount = 0; + + i = ObjectDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < ObjectData.Length) { + int blockLength = ObjectData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++ObjectDataCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)ObjectDataCount; + for (i = ObjectDataStart; i < ObjectDataStart + ObjectDataCount; i++) { ObjectData[i].ToBytes(packet, ref length); } + ObjectDataStart += ObjectDataCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -71458,7 +81004,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += TransferData.Length;; + length += TransferData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -71468,6 +81014,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -71632,7 +81182,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += XferID.Length; length += DataPacket.Length;; + length += XferID.Length; + length += DataPacket.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -71643,6 +81194,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -71747,7 +81302,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += XferID.Length;; + length += XferID.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -71757,6 +81312,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -72045,7 +81604,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += Sender.Length;; + length += Sender.Length; length++; for (int j = 0; j < AnimationList.Length; j++) { length += AnimationList[j].Length; } length++; @@ -72067,6 +81626,99 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += Sender.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + Sender.ToBytes(fixedBytes, ref i); + fixedLength += 3; + + int AnimationListStart = 0; + int AnimationSourceListStart = 0; + int PhysicalAvatarEventListStart = 0; + while ( + AnimationListStart < AnimationList.Length || + AnimationSourceListStart < AnimationSourceList.Length || + PhysicalAvatarEventListStart < PhysicalAvatarEventList.Length) + { + int variableLength = 0; + int AnimationListCount = 0; + int AnimationSourceListCount = 0; + int PhysicalAvatarEventListCount = 0; + + i = AnimationListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AnimationList.Length) { + int blockLength = AnimationList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AnimationListCount; + } + else { break; } + ++i; + } + + i = AnimationSourceListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AnimationSourceList.Length) { + int blockLength = AnimationSourceList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AnimationSourceListCount; + } + else { break; } + ++i; + } + + i = PhysicalAvatarEventListStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < PhysicalAvatarEventList.Length) { + int blockLength = PhysicalAvatarEventList[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++PhysicalAvatarEventListCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)AnimationListCount; + for (i = AnimationListStart; i < AnimationListStart + AnimationListCount; i++) { AnimationList[i].ToBytes(packet, ref length); } + AnimationListStart += AnimationListCount; + + packet[length++] = (byte)AnimationSourceListCount; + for (i = AnimationSourceListStart; i < AnimationSourceListStart + AnimationSourceListCount; i++) { AnimationSourceList[i].ToBytes(packet, ref length); } + AnimationSourceListStart += AnimationSourceListCount; + + packet[length++] = (byte)PhysicalAvatarEventListCount; + for (i = PhysicalAvatarEventListStart; i < PhysicalAvatarEventListStart + PhysicalAvatarEventListCount; i++) { PhysicalAvatarEventList[i].ToBytes(packet, ref length); } + PhysicalAvatarEventListStart += PhysicalAvatarEventListCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -72227,7 +81879,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += SitObject.Length; length += SitTransform.Length;; + length += SitObject.Length; + length += SitTransform.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -72238,6 +81891,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -72340,7 +81997,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += CameraCollidePlane.Length;; + length += CameraCollidePlane.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -72350,6 +82007,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -72712,7 +82373,8 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += ParcelData.Length; length += AgeVerificationBlock.Length;; + length += ParcelData.Length; + length += AgeVerificationBlock.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -72723,6 +82385,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -73237,7 +82903,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; length++; for (int j = 0; j < GroupData.Length; j++) { length += GroupData[j].Length; } length++; @@ -73267,6 +82933,135 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + System.Collections.Generic.List packets = new System.Collections.Generic.List(); + int i = 0; + int fixedLength = 7; + + byte[] ackBytes = null; + int acksLength = 0; + if (Header.AckList != null && Header.AckList.Length > 0) { + Header.AppendedAcks = true; + ackBytes = new byte[Header.AckList.Length * 4 + 1]; + Header.AcksToBytes(ackBytes, ref acksLength); + } + + fixedLength += AgentData.Length; + byte[] fixedBytes = new byte[fixedLength]; + Header.ToBytes(fixedBytes, ref i); + AgentData.ToBytes(fixedBytes, ref i); + fixedLength += 5; + + int GroupDataStart = 0; + int AnimationDataStart = 0; + int GranterBlockStart = 0; + int NVPairDataStart = 0; + int VisualParamStart = 0; + while ( + GroupDataStart < GroupData.Length || + AnimationDataStart < AnimationData.Length || + GranterBlockStart < GranterBlock.Length || + NVPairDataStart < NVPairData.Length || + VisualParamStart < VisualParam.Length) + { + int variableLength = 0; + int GroupDataCount = 0; + int AnimationDataCount = 0; + int GranterBlockCount = 0; + int NVPairDataCount = 0; + int VisualParamCount = 0; + + i = GroupDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < GroupData.Length) { + int blockLength = GroupData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++GroupDataCount; + } + else { break; } + ++i; + } + + i = AnimationDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < AnimationData.Length) { + int blockLength = AnimationData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++AnimationDataCount; + } + else { break; } + ++i; + } + + i = GranterBlockStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < GranterBlock.Length) { + int blockLength = GranterBlock[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++GranterBlockCount; + } + else { break; } + ++i; + } + + i = NVPairDataStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < NVPairData.Length) { + int blockLength = NVPairData[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++NVPairDataCount; + } + else { break; } + ++i; + } + + i = VisualParamStart; + while (fixedLength + variableLength + acksLength < Packet.MTU && i < VisualParam.Length) { + int blockLength = VisualParam[i].Length; + if (fixedLength + variableLength + blockLength + acksLength <= MTU) { + variableLength += blockLength; + ++VisualParamCount; + } + else { break; } + ++i; + } + + byte[] packet = new byte[fixedLength + variableLength + acksLength]; + int length = fixedBytes.Length; + Buffer.BlockCopy(fixedBytes, 0, packet, 0, length); + if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); } + + packet[length++] = (byte)GroupDataCount; + for (i = GroupDataStart; i < GroupDataStart + GroupDataCount; i++) { GroupData[i].ToBytes(packet, ref length); } + GroupDataStart += GroupDataCount; + + packet[length++] = (byte)AnimationDataCount; + for (i = AnimationDataStart; i < AnimationDataStart + AnimationDataCount; i++) { AnimationData[i].ToBytes(packet, ref length); } + AnimationDataStart += AnimationDataCount; + + packet[length++] = (byte)GranterBlockCount; + for (i = GranterBlockStart; i < GranterBlockStart + GranterBlockCount; i++) { GranterBlock[i].ToBytes(packet, ref length); } + GranterBlockStart += GranterBlockCount; + + packet[length++] = (byte)NVPairDataCount; + for (i = NVPairDataStart; i < NVPairDataStart + NVPairDataCount; i++) { NVPairData[i].ToBytes(packet, ref length); } + NVPairDataStart += NVPairDataCount; + + packet[length++] = (byte)VisualParamCount; + for (i = VisualParamStart; i < VisualParamStart + VisualParamCount; i++) { VisualParam[i].ToBytes(packet, ref length); } + VisualParamStart += VisualParamCount; + + if (acksLength > 0) { + Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength); + acksLength = 0; + } + + packets.Add(packet); + } + + return packets.ToArray(); + } } /// @@ -73377,7 +83172,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -73387,6 +83182,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -73521,7 +83320,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += AgentData.Length;; + length += AgentData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -73531,6 +83330,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } /// @@ -73650,7 +83453,7 @@ namespace OpenMetaverse.Packets public override byte[] ToBytes() { int length = 7; - length += SoundData.Length;; + length += SoundData.Length; if (Header.AckList != null && Header.AckList.Length > 0) { length += Header.AckList.Length * 4 + 1; } byte[] bytes = new byte[length]; int i = 0; @@ -73660,6 +83463,10 @@ namespace OpenMetaverse.Packets return bytes; } + public override byte[][] ToBytesMultiple() + { + return new byte[][] { ToBytes() }; + } } } diff --git a/Programs/mapgenerator/mapgenerator.cs b/Programs/mapgenerator/mapgenerator.cs index fbc713ba..eaafd830 100644 --- a/Programs/mapgenerator/mapgenerator.cs +++ b/Programs/mapgenerator/mapgenerator.cs @@ -602,7 +602,8 @@ namespace mapgenerator } writer.WriteLine(" }" + Environment.NewLine); - // ToBytes() function + #region ToBytes() Function + //writer.WriteLine(" /// Serialize this packet to a byte arrayA byte array containing the serialized packet"); writer.WriteLine(" public override byte[] ToBytes()" + Environment.NewLine + " {"); @@ -619,10 +620,9 @@ namespace mapgenerator if (block.Count == 1) { // Single count block - writer.Write(" length += " + sanitizedName + ".Length;"); + writer.WriteLine(" length += " + sanitizedName + ".Length;"); } } - writer.WriteLine(";"); foreach (MapBlock block in packet.Blocks) { @@ -673,9 +673,228 @@ namespace mapgenerator writer.WriteLine(" if (Header.AckList != null && Header.AckList.Length > 0) { Header.AcksToBytes(bytes, ref i); }"); writer.WriteLine(" return bytes;" + Environment.NewLine + " }" + Environment.NewLine); + #endregion ToBytes() Function + + WriteToBytesMultiple(writer, packet); + writer.WriteLine(" }" + Environment.NewLine); } + static void WriteToBytesMultiple(TextWriter writer, MapPacket packet) + { + writer.WriteLine( + " public override byte[][] ToBytesMultiple()" + Environment.NewLine + + " {"); + + // Check if there are any variable blocks + bool hasVariable = false; + foreach (MapBlock block in packet.Blocks) + { + if (block.Count == -1) + { + hasVariable = true; + break; + } + } + + if (hasVariable) + { + writer.WriteLine( + " System.Collections.Generic.List packets = new System.Collections.Generic.List();"); + writer.WriteLine( + " int i = 0;"); + writer.Write( + " int fixedLength = "); + if (packet.Frequency == PacketFrequency.Low) { writer.WriteLine("10;"); } + else if (packet.Frequency == PacketFrequency.Medium) { writer.WriteLine("8;"); } + else { writer.WriteLine("7;"); } + writer.WriteLine(); + + // ACK serialization + writer.WriteLine(" byte[] ackBytes = null;"); + writer.WriteLine(" int acksLength = 0;"); + writer.WriteLine(" if (Header.AckList != null && Header.AckList.Length > 0) {"); + writer.WriteLine(" Header.AppendedAcks = true;"); + writer.WriteLine(" ackBytes = new byte[Header.AckList.Length * 4 + 1];"); + writer.WriteLine(" Header.AcksToBytes(ackBytes, ref acksLength);"); + writer.WriteLine(" }"); + writer.WriteLine(); + + // Count fixed blocks + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == 1) + { + // Single count block + writer.WriteLine(" fixedLength += " + sanitizedName + ".Length;"); + } + else if (block.Count > 0) + { + // Fixed count block + writer.WriteLine(" for (int j = 0; j < " + block.Count + "; j++) { fixedLength += " + sanitizedName + "[j].Length; }"); + } + } + + // Serialize fixed blocks + writer.WriteLine( + " byte[] fixedBytes = new byte[fixedLength];"); + writer.WriteLine( + " Header.ToBytes(fixedBytes, ref i);"); + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == 1) + { + // Single count block + writer.WriteLine(" " + sanitizedName + ".ToBytes(fixedBytes, ref i);"); + } + else if (block.Count > 0) + { + // Fixed count block + writer.WriteLine(" for (int j = 0; j < " + block.Count + "; j++) { " + sanitizedName + "[j].ToBytes(fixedBytes, ref i); }"); + } + } + + int variableCountBlock = 0; + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == -1) + { + // Variable count block + ++variableCountBlock; + } + } + writer.WriteLine(" fixedLength += " + variableCountBlock + ";"); + writer.WriteLine(); + + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == -1) + { + // Variable count block + writer.WriteLine(" int " + sanitizedName + "Start = 0;"); + } + } + + bool first = true; + writer.WriteLine(" while ("); + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == -1) + { + if (first) first = false; + else writer.WriteLine(" ||"); + + // Variable count block + writer.Write(" " + sanitizedName + "Start < " + sanitizedName + ".Length"); + } + } + writer.WriteLine(")"); + writer.WriteLine(" {"); + + // Count how many variable blocks can go in this packet + writer.WriteLine(" int variableLength = 0;"); + + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == -1) + { + // Variable count block + writer.WriteLine(" int " + sanitizedName + "Count = 0;"); + } + } + writer.WriteLine(); + + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == -1) + { + // Variable count block + writer.WriteLine(" i = " + sanitizedName + "Start;"); + writer.WriteLine(" while (fixedLength + variableLength + acksLength < Packet.MTU && i < " + sanitizedName + ".Length) {"); + writer.WriteLine(" int blockLength = " + sanitizedName + "[i].Length;"); + writer.WriteLine(" if (fixedLength + variableLength + blockLength + acksLength <= MTU) {"); + writer.WriteLine(" variableLength += blockLength;"); + writer.WriteLine(" ++" + sanitizedName + "Count;"); + writer.WriteLine(" }"); + writer.WriteLine(" else { break; }"); + writer.WriteLine(" ++i;"); + writer.WriteLine(" }"); + writer.WriteLine(); + } + } + + // Create the packet + writer.WriteLine(" byte[] packet = new byte[fixedLength + variableLength + acksLength];"); + writer.WriteLine(" int length = fixedBytes.Length;"); + writer.WriteLine(" Buffer.BlockCopy(fixedBytes, 0, packet, 0, length);"); + // Remove the appended ACKs flag from subsequent packets + writer.WriteLine(" if (packets.Count > 0) { packet[0] = (byte)(packet[0] & ~0x10); }"); + writer.WriteLine(); + + foreach (MapBlock block in packet.Blocks) + { + string sanitizedName; + if (block.Name == "Header") { sanitizedName = "_" + block.Name; } + else { sanitizedName = block.Name; } + + if (block.Count == -1) + { + writer.WriteLine(" packet[length++] = (byte)" + sanitizedName + "Count;"); + writer.WriteLine(" for (i = " + sanitizedName + "Start; i < " + sanitizedName + "Start + " + + sanitizedName + "Count; i++) { " + sanitizedName + "[i].ToBytes(packet, ref length); }"); + writer.WriteLine(" " + sanitizedName + "Start += " + sanitizedName + "Count;"); + writer.WriteLine(); + } + } + + // ACK appending + writer.WriteLine(" if (acksLength > 0) {"); + writer.WriteLine(" Buffer.BlockCopy(ackBytes, 0, packet, length, acksLength);"); + writer.WriteLine(" acksLength = 0;"); + writer.WriteLine(" }"); + writer.WriteLine(); + + writer.WriteLine(" packets.Add(packet);"); + writer.WriteLine(" }"); + writer.WriteLine(); + writer.WriteLine(" return packets.ToArray();"); + writer.WriteLine(" }"); + } + else + { + writer.WriteLine(" return new byte[][] { ToBytes() };"); + writer.WriteLine(" }"); + } + } + static int Main(string[] args) { ProtocolManager protocol; @@ -756,14 +975,17 @@ namespace mapgenerator // Write the base Packet class writer.WriteLine( " public abstract partial class Packet" + Environment.NewLine + " {" + Environment.NewLine + + " public const int MTU = 1200;" + Environment.NewLine + + Environment.NewLine + " public Header Header;" + Environment.NewLine + " public PacketType Type;" + Environment.NewLine + " public abstract int Length { get; }" + Environment.NewLine + " public abstract void FromBytes(byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer);" + Environment.NewLine + " public abstract void FromBytes(Header header, byte[] bytes, ref int i, ref int packetEnd, byte[] zeroBuffer);" + Environment.NewLine + - " public abstract byte[] ToBytes();" + " public abstract byte[] ToBytes();" + Environment.NewLine + + " public abstract byte[][] ToBytesMultiple();" ); - + writer.WriteLine(); // Write the Packet.GetType() function writer.WriteLine(