// Sends a byte[] to the a client given it's ID
public void Send(byte[] data, int length, ulong id, bool temporary = false)
{
try{
if (!temporary)
{
IAsyncResult lenResult = this.connections[id].BeginSend(this.LengthPacket(length), 0, 4, 0, out this.err, null, id);
this.connections[id].EndSend(lenResult);
IAsyncResult result = this.connections[id].BeginSend(data, 0, length, 0, out this.err, null, id);
this.connections[id].EndSend(result);
NetMessage.Broadcast(NetBroadcast.SENT, data[0], id, length);
}
else
{
IAsyncResult lenResult = this.temporaryConnections[id].BeginSend(this.LengthPacket(length), 0, 4, 0, out this.err, null, id);
this.temporaryConnections[id].EndSend(lenResult);
IAsyncResult result = this.temporaryConnections[id].BeginSend(data, 0, length, 0, out this.err, null, id);
this.temporaryConnections[id].EndSend(result);
NetMessage.Broadcast(NetBroadcast.SENT, data[0], id, length);
}
}
catch (Exception e) {
Debug.Log("SEND ERROR: " + e.ToString());
}
}
// Receive call handling
private void ReceiveCallback(IAsyncResult result)
{
try{
// Resets timeout timer
this.lastMessageTime = DateTime.Now;
int bytesReceived = this.socket.EndReceive(result);
// If has received a length Packet
if (this.lengthPacket)
{
int size = NetDecoder.ReadInt(receiveBuffer, 0);
// Ignores packets that are way too big
if (size > Client.maxBufferSize)
{
this.socket.BeginReceive(receiveBuffer, 0, size, 0, out this.err, new AsyncCallback(ReceiveCallback), null);
return;
}
this.dataBuffer = new byte[size];
this.packetSize = size;
this.packetIndex = 0;
this.lengthPacket = false;
this.socket.BeginReceive(receiveBuffer, 0, size, 0, out this.err, new AsyncCallback(ReceiveCallback), null);
return;
}
// If has received a segmented packet
if (bytesReceived + this.packetIndex < this.packetSize)
{
Array.Copy(receiveBuffer, 0, this.dataBuffer, this.packetIndex, bytesReceived);
this.packetIndex = this.packetIndex + bytesReceived;
this.socket.BeginReceive(receiveBuffer, 0, this.packetSize - this.packetIndex, 0, out this.err, new AsyncCallback(ReceiveCallback), null);
return;
}
Array.Copy(receiveBuffer, 0, this.dataBuffer, this.packetIndex, bytesReceived);
NetMessage.Broadcast(NetBroadcast.RECEIVED, dataBuffer[0], 0, this.packetSize);
NetMessage receivedMessage = new NetMessage(this.dataBuffer, 0);
this.queue.Add(receivedMessage);
this.lengthPacket = true;
this.packetSize = 0;
this.packetIndex = 0;
this.socket.BeginReceive(receiveBuffer, 0, 4, 0, out this.err, new AsyncCallback(ReceiveCallback), null);
}
catch (Exception e) {
Debug.Log(e.ToString());
}
}
/*
* =========================================================================
* Handling of NetMessages
*/
// Discovers what to do with a Message received from Server
public void HandleReceivedMessage(byte[] data)
{
if (data == null)
{
return;
}
if (data.Length == 0)
{
return;
}
NetMessage.Broadcast(NetBroadcast.PROCESSED, data[0], 0, 0);
switch ((NetCode)data[0])
{
case NetCode.ACCEPTEDCONNECT:
AcceptConnect();
break;
case NetCode.SENDSERVERINFO:
SendServerInfo(data);
break;
case NetCode.SENDCHUNK:
SendChunk(data);
break;
case NetCode.DISCONNECT:
Disconnect();
break;
case NetCode.DIRECTBLOCKUPDATE:
DirectBlockUpdate(data);
break;
case NetCode.VFXDATA:
VFXData(data);
break;
case NetCode.VFXCHANGE:
VFXChange(data);
break;
case NetCode.VFXBREAK:
VFXBreak(data);
break;
case NetCode.SENDGAMETIME:
SendGameTime(data);
break;
case NetCode.PLAYERDATA:
PlayerData(data);
break;
case NetCode.ENTITYDELETE:
EntityDelete(data);
break;
case NetCode.PLACEMENTDENIED:
PlacementDenied();
break;
case NetCode.ITEMENTITYDATA:
ItemEntityData(data);
break;
case NetCode.BLOCKDAMAGE:
BlockDamage(data);
break;
case NetCode.FAILEDCHUNKREQUEST:
FailedChunkRequest(data);
break;
default:
Debug.Log("UNKNOWN NETMESSAGE RECEIVED: " + (NetCode)data[0]);
break;
}
}
/* ===========================
* Handling of NetMessages
*/
// Discovers what to do with a Message received from Server
public void HandleReceivedMessage(byte[] data, ulong id)
{
try{
NetMessage.Broadcast(NetBroadcast.PROCESSED, data[0], id, 0);
}
catch {
return;
}
switch ((NetCode)data[0])
{
case NetCode.SENDCLIENTINFO:
SendClientInfo(data, id);
break;
case NetCode.REQUESTCHUNKLOAD:
RequestChunkLoad(data, id);
break;
case NetCode.REQUESTCHUNKUNLOAD:
RequestChunkUnload(data, id);
break;
case NetCode.SENDBUD:
SendBUD(data);
break;
case NetCode.DIRECTBLOCKUPDATE:
DirectBlockUpdate(data, id);
break;
case NetCode.CLIENTPLAYERPOSITION:
ClientPlayerPosition(data, id);
break;
case NetCode.DISCONNECT:
Disconnect(id, DisconnectType.QUIT);
break;
case NetCode.INTERACT:
Interact(data);
break;
case NetCode.HEARTBEAT:
Heartbeat(id);
break;
case NetCode.CLIENTCHUNK:
ClientChunk(data, id);
break;
case NetCode.DROPITEM:
DropItem(data, id);
break;
case NetCode.BATCHLOADBUD:
BatchLoadBUD(data, id);
break;
case NetCode.BLOCKDAMAGE:
BlockDamage(data, id);
break;
default:
Debug.Log("UNKNOWN NETMESSAGE RECEIVED");
break;
}
}
// Receive call handling
private void ReceiveCallback(IAsyncResult result)
{
try{
ulong currentID = (ulong)result.AsyncState;
bool isTemporary = false;
int bytesReceived;
// If receives something before attributing AccountID
if (this.temporaryConnections.ContainsKey(currentID))
{
isTemporary = true;
}
// Gets packet size
if (isTemporary)
{
bytesReceived = this.temporaryConnections[currentID].EndReceive(result);
}
else
{
bytesReceived = this.connections[currentID].EndReceive(result);
}
// If has received a size packet
if (this.lengthPacket[currentID])
{
int size = NetDecoder.ReadInt(this.receiveBuffer[currentID], 0);
this.dataBuffer[currentID] = new byte[size];
this.packetSize[currentID] = size;
this.lengthPacket[currentID] = false;
this.packetIndex[currentID] = 0;
if (isTemporary)
{
this.temporaryConnections[currentID].BeginReceive(this.receiveBuffer[currentID], 0, size, 0, out this.err, new AsyncCallback(ReceiveCallback), currentID);
}
else
{
this.connections[currentID].BeginReceive(this.receiveBuffer[currentID], 0, size, 0, out this.err, new AsyncCallback(ReceiveCallback), currentID);
}
return;
}
// If has received a segmented packet
if (bytesReceived + this.packetIndex[currentID] < this.packetSize[currentID])
{
Array.Copy(this.receiveBuffer[currentID], 0, this.dataBuffer[currentID], this.packetIndex[currentID], bytesReceived);
this.packetIndex[currentID] = this.packetIndex[currentID] + bytesReceived;
if (isTemporary)
{
this.temporaryConnections[currentID].BeginReceive(this.receiveBuffer[currentID], 0, this.packetSize[currentID] - this.packetIndex[currentID], 0, out this.err, new AsyncCallback(ReceiveCallback), currentID);
}
else
{
this.connections[currentID].BeginReceive(this.receiveBuffer[currentID], 0, this.packetSize[currentID] - this.packetIndex[currentID], 0, out this.err, new AsyncCallback(ReceiveCallback), currentID);
}
return;
}
// If has received the entire package
Array.Copy(this.receiveBuffer[currentID], 0, this.dataBuffer[currentID], this.packetIndex[currentID], bytesReceived);
NetMessage.Broadcast(NetBroadcast.RECEIVED, this.dataBuffer[currentID][0], currentID, this.packetSize[currentID]);
NetMessage receivedMessage = new NetMessage(this.dataBuffer[currentID], currentID);
this.queue.Add(receivedMessage);
this.lengthPacket[currentID] = true;
this.packetIndex[currentID] = 0;
this.packetSize[currentID] = 0;
if (!isTemporary)
{
this.connections[currentID].BeginReceive(this.receiveBuffer[currentID], 0, 4, 0, out this.err, new AsyncCallback(ReceiveCallback), currentID);
}
}
catch (SocketException e) {
Debug.Log(e.Message + "\n" + e.StackTrace);
}
}
