//---------------------------------------------------------------------------------------------//
//Public functions:
//---------------------------------------------------------------------------------------------//
public void Connected()
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[OK] Connected");
state = TCP_Connection_State.TCPC_Connected;
this.thread = new Thread(TCP_ConnectionThread);
this.thread.Name = "[NET_TCP] connection thread";
this.thread.Start();
}
private void TCP_Receive()
{
if (stream.DataAvailable == true)
{
try
{
byte[] messageData = null;
using (MemoryStream ms = new MemoryStream())
{
//Read byte size of message
byte[] header = new byte[8];
byte[] message = new byte[1];
this.stream.Read(header, 0, 8);
if (header[0] == 65 && header[1] == 81 && header[2] == 69 && header[3] == 88)
{
int totalSize = BitConverter.ToInt32(header, 4);
int size = totalSize;
//Read main message
while (size > 0)
{
byte[] buffer = new byte[size];
int received = this.stream.Read(buffer, 0, size);
ms.Write(buffer, 0, received);
size -= received;
}
messageData = ms.ToArray();
}
else
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[ERROR] Wrong header");
}
}
//Deserialize message
if (messageData != null)
{
NET_Messages.IMessage deserialized = TCP_Deserialize(messageData);
if (deserialized != null)
{
lock (tcpIN_MessageQueue)
{
tcpIN_MessageQueue.Enqueue(deserialized);
}
}
}
}
catch
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[ERROR] Receiving");
//Nothing to do here...
}
}
Thread.Sleep(1);
}
private void TCP_Sending()
{
NET_Messages.IMessage message;
if (tcpOUT_MessageQueue.Count > 0)
{
//Copy out queue to sen queue
lock (tcpOUT_MessageQueue)
{
tcpSEN_MessageQueue = new Queue <NET_Messages.IMessage>(tcpOUT_MessageQueue);
tcpOUT_MessageQueue.Clear();
}
lock (tcpSEN_MessageQueue)
{
while (tcpSEN_MessageQueue.Count > 0)
{
message = tcpSEN_MessageQueue.Dequeue();
byte[] messageData = TCP_Serialize(message);
if (messageData != null)
{
sendRetryCount = 0;
bool retryResult = false;
//Sending first try...
retryResult = TCP_Send(messageData);
//Sending failed --> Retry!
while (retryResult == false && sendRetryCount < 5)
{
retryResult = TCP_Send(messageData);
sendRetryCount++;
NET_Debug.InjectMessage("[NET_TCP_CN]", "[ERROR] Senging: Retrying " + sendRetryCount);
Thread.Sleep(1);
}
if (sendRetryCount == 5)
{
//This is bad! The message was not sendable
//--> Target disconnected?
NET_Debug.InjectMessage("[NET_TCP_CN]", "[FATAL ERROR] Senging");
}
}
else
{
//This is really bad! The message was not serializable...
}
Thread.Sleep(1);
}
}
}
}
//---------------------------------------------------------------------------------------------//
//Private functions:
//---------------------------------------------------------------------------------------------//
private void TCP_ConnectionThread()
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[OK] Thread started");
//While connection established
while (state == TCP_Connection_State.TCPC_Connected)
{
TCP_Receive();
TCP_Sending();
}
client.Client.Disconnect(true);
stream.Close();
stream.Dispose();
client.Close();
NET_Debug.InjectMessage("[NET_TCP_CN]", "[OK] Thread ended");
this.state = TCP_Connection_State.TCPC_DeleteMe;
}
public void Disconnect(int playerID)
{
if (state == TCP_Connection_State.TCPC_Connected)
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[OK] Disconnected");
NET_Messages.NET_Message_Disconnect disconnectMessage = new NET_Messages.NET_Message_Disconnect(DateTime.Now);
NET_DataPack pack = new NET_DataPack();
pack.SetData("PlayerID", playerID);
disconnectMessage.SetData(pack.SerializeData());
lock (tcpOUT_MessageQueue)
{
tcpOUT_MessageQueue.Enqueue(disconnectMessage);
}
TCP_Sending();
this.state = TCP_Connection_State.TCPC_Disconnected;
}
}
private byte[] TCP_Serialize(NET_Messages.IMessage message)
{
try
{
BinaryFormatter binForm = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
binForm.Serialize(ms, message);
return(ms.ToArray());
}
}
catch
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[FATAL ERROR] Serializing failed");
return(null);
}
}
private NET_Messages.IMessage TCP_Deserialize(byte[] messageData)
{
try
{
BinaryFormatter binForm = new BinaryFormatter();
using (MemoryStream memStream = new MemoryStream())
{
memStream.Write(messageData, 0, messageData.Length);
memStream.Seek(0, SeekOrigin.Begin);
object obj = (object)binForm.Deserialize(memStream);
return(obj as NET_Messages.IMessage);
}
}
catch
{
NET_Debug.InjectMessage("[NET_TCP_CN]", "[FATAL ERROR] Deserializing failed");
return(null);
}
}
/// <summary>
/// Central network control.
/// </summary>
/// <param name="isHost">Sets the NET_Main to server or client mode</param>
/// <param name="timeStep">Heartbeat of the server</param>
/// <param name="name">Servername</param>
/// <param name="log"></param>
public NET_Main(bool isHost, float timeStep, string name, bool log)
{
this.name = name;
this.timeStep = timeStep;
this.isHost = isHost;
if (isHost == true)
{
this.playerID = 1;
}
if (log == false)
{
NET_Debug.DeactivateLogging();
}
playersGameData[0] = new NET_DataPack();
playersGameData[1] = new NET_DataPack();
playersGameData[2] = new NET_DataPack();
playersGameData[3] = new NET_DataPack();
}
