/// <summary>
/// Copy the contents of this buffer into the target one, trimming away unused space.
/// </summary>
public void CopyTo (Buffer target)
{
BinaryWriter w = target.BeginWriting(false);
int bytes = size;
if (bytes > 0) w.Write(buffer, position, bytes);
target.EndWriting();
}
/// <summary>
/// Add a new saved remote function call.
/// </summary>
public void AddRFC(uint uid, string funcName, Buffer buffer)
{
if (closed || buffer == null)
{
return;
}
uint objID = (uid >> 8);
// Ignore objects that don't exist
if (objID < 32768)
{
if (destroyed.Contains(objID))
{
return;
}
}
else if (!mCreatedObjectDictionary.ContainsKey(objID))
{
return;
}
Buffer b = Buffer.Create();
b.BeginWriting(false).Write(buffer.buffer, buffer.position, buffer.size);
b.EndWriting();
for (int i = 0; i < rfcs.size; ++i)
{
RFC r = rfcs[i];
if (r.uid == uid && r.functionName == funcName)
{
if (r.data != null)
{
r.data.Recycle();
}
r.data = b;
return;
}
}
RFC rfc = new RFC();
rfc.uid = uid;
rfc.data = b;
rfc.functionName = funcName;
rfcs.Add(rfc);
}
/// <summary>
/// Load the channel's data from the specified file.
/// </summary>
public bool LoadFrom(BinaryReader reader)
{
int version = reader.ReadInt32();
if (version < 20160207)
{
#if UNITY_EDITOR
UnityEngine.Debug.LogWarning("Incompatible data: " + version);
#endif
return(false);
}
// Clear all RFCs, just in case
for (int i = 0; i < rfcs.size; ++i)
{
RFC r = rfcs[i];
if (r.data != null)
{
r.data.Recycle();
}
}
rfcs.Clear();
created.Clear();
destroyed.Clear();
mCreatedObjectDictionary.Clear();
level = reader.ReadString();
dataNode = reader.ReadDataNode();
objectCounter = reader.ReadUInt32();
password = reader.ReadString();
persistent = reader.ReadBoolean();
playerLimit = reader.ReadUInt16();
int size = reader.ReadInt32();
for (int i = 0; i < size; ++i)
{
RFC rfc = new RFC();
rfc.uid = reader.ReadUInt32();
if (rfc.functionID == 0)
{
rfc.functionName = reader.ReadString();
}
Buffer b = Buffer.Create();
b.BeginWriting(false).Write(reader.ReadBytes(reader.ReadInt32()));
b.EndWriting();
rfc.data = b;
rfcs.Add(rfc);
}
size = reader.ReadInt32();
for (int i = 0; i < size; ++i)
{
CreatedObject co = new CreatedObject();
co.playerID = reader.ReadInt32();
co.objectID = reader.ReadUInt32();
co.type = 1;
Buffer b = Buffer.Create();
b.BeginWriting(false).Write(reader.ReadBytes(reader.ReadInt32()));
b.EndWriting();
co.buffer = b;
AddCreatedObject(co);
}
size = reader.ReadInt32();
for (int i = 0; i < size; ++i)
{
uint uid = reader.ReadUInt32();
if (uid < 32768)
{
destroyed.Add(uid);
}
}
isLocked = reader.ReadBoolean();
return(true);
}
/// <summary>
/// Channel joining process involves multiple steps. It's faster to perform them all at once.
/// </summary>
public void FinishJoiningChannel()
{
Buffer buffer = Buffer.Create();
// Step 2: Tell the player who else is in the channel
BinaryWriter writer = buffer.BeginPacket(Packet.ResponseJoiningChannel);
{
writer.Write(channel.id);
writer.Write((short)channel.players.size);
for (int i = 0; i < channel.players.size; ++i)
{
TcpPlayer tp = channel.players[i];
writer.Write(tp.id);
writer.Write(string.IsNullOrEmpty(tp.name) ? "Guest" : tp.name);
}
}
// End the first packet, but remember where it ended
int offset = buffer.EndPacket();
// Step 3: Inform the player of who is hosting
if (channel.host == null)
{
channel.host = this;
}
buffer.BeginPacket(Packet.ResponseSetHost, offset);
writer.Write(channel.host.id);
offset = buffer.EndTcpPacketStartingAt(offset);
// Step 4: Send the channel's data
if (!string.IsNullOrEmpty(channel.data))
{
buffer.BeginPacket(Packet.ResponseSetChannelData, offset);
writer.Write(channel.data);
offset = buffer.EndTcpPacketStartingAt(offset);
}
// Step 5: Inform the player of what level we're on
buffer.BeginPacket(Packet.ResponseLoadLevel, offset);
writer.Write(string.IsNullOrEmpty(channel.level) ? "" : channel.level);
offset = buffer.EndTcpPacketStartingAt(offset);
// Step 6: Send the list of objects that have been created
for (int i = 0; i < channel.created.size; ++i)
{
Channel.CreatedObject obj = channel.created.buffer[i];
buffer.BeginPacket(Packet.ResponseCreate, offset);
writer.Write(obj.playerID);
writer.Write(obj.objectID);
writer.Write(obj.uniqueID);
writer.Write(obj.buffer.buffer, obj.buffer.position, obj.buffer.size);
offset = buffer.EndTcpPacketStartingAt(offset);
}
// Step 7: Send the list of objects that have been destroyed
if (channel.destroyed.size != 0)
{
buffer.BeginPacket(Packet.ResponseDestroy, offset);
writer.Write((ushort)channel.destroyed.size);
for (int i = 0; i < channel.destroyed.size; ++i)
{
writer.Write(channel.destroyed.buffer[i]);
}
offset = buffer.EndTcpPacketStartingAt(offset);
}
// Step 8: Send all buffered RFCs to the new player
for (int i = 0; i < channel.rfcs.size; ++i)
{
Buffer rfcBuff = channel.rfcs[i].buffer;
rfcBuff.BeginReading();
buffer.BeginWriting(offset);
writer.Write(rfcBuff.buffer, rfcBuff.position, rfcBuff.size);
offset = buffer.EndWriting();
}
// Step 9: The join process is now complete
buffer.BeginPacket(Packet.ResponseJoinChannel, offset);
writer.Write(true);
offset = buffer.EndTcpPacketStartingAt(offset);
// Send the entire buffer
SendTcpPacket(buffer);
buffer.Recycle();
}
/// <summary>
/// Copy the contents of this buffer into the target one, trimming away unused space.
/// </summary>
public void CopyTo(Buffer target)
{
BinaryWriter w = target.BeginWriting(false);
int bytes = size;
if (bytes > 0) w.Write(buffer, position, bytes);
target.EndWriting();
}
/// <summary>
/// Send the specified packet. Marks the buffer as used.
/// </summary>
public void SendTcpPacket(Buffer buffer)
{
buffer.MarkAsUsed();
BinaryReader reader = buffer.BeginReading();
#if DEBUG_PACKETS && !STANDALONE
Packet packet = (Packet)buffer.PeekByte(4);
if (packet != Packet.RequestPing && packet != Packet.ResponsePing)
{
UnityEngine.Debug.Log("Sending: " + packet + " to " + name + " (" + (buffer.size - 5).ToString("N0") + " bytes)");
}
#endif
if (mSocket != null && mSocket.Connected)
{
lock (mOut)
{
mOut.Enqueue(buffer);
// If it's the first packet, let's begin the send process
if (mOut.Count == 1)
{
try
{
#if !UNITY_WINRT
mSocket.BeginSend(buffer.buffer, buffer.position, buffer.size, SocketFlags.None, OnSend, buffer);
#endif
}
catch (System.Exception ex)
{
mOut.Clear();
buffer.Recycle();
RespondWithError(ex);
CloseNotThreadSafe(false);
}
}
}
return;
}
if (sendQueue != null)
{
if (buffer.position != 0)
{
// Offline mode sends packets individually and they should not be reused
#if UNITY_EDITOR
Debug.LogWarning("Packet's position is " + buffer.position + " instead of 0. Potentially sending the same packet more than once. Ignoring...");
#endif
return;
}
// Skip the packet's size
int size = reader.ReadInt32();
if (size == buffer.size)
{
// Note that after this the buffer can no longer be used again as its offset is +4
lock (sendQueue) sendQueue.Enqueue(buffer);
return;
}
// Multi-part packet -- split it up into separate ones
lock (sendQueue)
{
for (;;)
{
byte[] bytes = reader.ReadBytes(size);
Buffer temp = Buffer.Create();
BinaryWriter writer = temp.BeginWriting();
writer.Write(size);
writer.Write(bytes);
temp.BeginReading(4);
temp.EndWriting();
sendQueue.Enqueue(temp);
if (buffer.size > 0)
{
size = reader.ReadInt32();
}
else
{
break;
}
}
}
}
buffer.Recycle();
}
/// <summary>
/// Channel joining process involves multiple steps. It's faster to perform them all at once.
/// </summary>
public void FinishJoiningChannel()
{
Buffer buffer = Buffer.Create();
// Step 2: Tell the player who else is in the channel
BinaryWriter writer = buffer.BeginPacket(Packet.ResponseJoiningChannel);
{
writer.Write(channel.id);
writer.Write((short)channel.players.size);
for (int i = 0; i < channel.players.size; ++i)
{
TcpPlayer tp = channel.players[i];
writer.Write(tp.id);
writer.Write(string.IsNullOrEmpty(tp.name) ? "Guest" : tp.name);
#if STANDALONE
if (tp.data == null)
{
writer.Write((byte)0);
}
else
{
writer.Write((byte[])tp.data);
}
#else
writer.WriteObject(tp.data);
#endif
}
}
// End the first packet, but remember where it ended
int offset = buffer.EndPacket();
// Step 3: Inform the player of who is hosting
if (channel.host == null)
{
channel.host = this;
}
buffer.BeginPacket(Packet.ResponseSetHost, offset);
writer.Write(channel.host.id);
offset = buffer.EndTcpPacketStartingAt(offset);
// Step 4: Send the channel's data
if (!string.IsNullOrEmpty(channel.data))
{
buffer.BeginPacket(Packet.ResponseSetChannelData, offset);
writer.Write(channel.data);
offset = buffer.EndTcpPacketStartingAt(offset);
}
// Step 5: Inform the player of what level we're on
buffer.BeginPacket(Packet.ResponseLoadLevel, offset);
writer.Write(string.IsNullOrEmpty(channel.level) ? "" : channel.level);
offset = buffer.EndTcpPacketStartingAt(offset);
// Step 6: Send the list of objects that have been created
for (int i = 0; i < channel.created.size; ++i)
{
Channel.CreatedObject obj = channel.created.buffer[i];
bool isPresent = false;
for (int b = 0; b < channel.players.size; ++b)
{
if (channel.players[b].id == obj.playerID)
{
isPresent = true;
break;
}
}
// If the previous owner is not present, transfer ownership to the host
if (!isPresent)
{
obj.playerID = channel.host.id;
}
buffer.BeginPacket(Packet.ResponseCreate, offset);
writer.Write(obj.playerID);
writer.Write(obj.objectIndex);
writer.Write(obj.objectID);
writer.Write(obj.buffer.buffer, obj.buffer.position, obj.buffer.size);
offset = buffer.EndTcpPacketStartingAt(offset);
}
// Step 7: Send the list of objects that have been destroyed
if (channel.destroyed.size != 0)
{
buffer.BeginPacket(Packet.ResponseDestroy, offset);
writer.Write((ushort)channel.destroyed.size);
for (int i = 0; i < channel.destroyed.size; ++i)
{
writer.Write(channel.destroyed.buffer[i]);
}
offset = buffer.EndTcpPacketStartingAt(offset);
}
// Step 8: Send all buffered RFCs to the new player
for (int i = 0; i < channel.rfcs.size; ++i)
{
Channel.RFC rfc = channel.rfcs[i];
buffer.BeginWriting(offset);
writer.Write(rfc.buffer.buffer, 0, rfc.buffer.size);
offset = buffer.EndWriting();
}
// Step 9: The join process is now complete
buffer.BeginPacket(Packet.ResponseJoinChannel, offset);
writer.Write(true);
offset = buffer.EndTcpPacketStartingAt(offset);
// Send the entire buffer
SendTcpPacket(buffer);
buffer.Recycle();
}