public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out PlayerName);
return(isOk);
}
private void NetMessageWriter_CatanClientAuth_Response_WriteCompleted(object obj, NetworkMessageWriterWriteCompletedEventArgs e)
{
//getDisconnectedClientConnections(silently:true);
// new catan client
CatanClient catanClient = new CatanClient(e.TcpClient, e.TcpClient.Client.RemoteEndPoint.ToString(), (e.NetMessage as CatanClientAuthenticationResponseMessage).AuthRequestMessage.Playername);
catanClients.Add(catanClient);
Console.WriteLine($"Catan player joined: {catanClient.Name}");
if (catanClients.Count == maxClients)
{
// Start game
tcpListener.Stop();
Thread.Sleep(1000);
catanClients.ForEach(client =>
{
var netReader = new NetworkMessageReader(client.TcpClient);
netReader.ReadCompleted += NetMessageReader_CatanClientMessageReceived;
netReader.ReadAsync(readLoop: true);
}); // error handling wird ignoriert !!!
iLogicLayer.ServerFinishedListening(catanClients);
}
}
public void StartTcpListener()
{
try
{
tcpListener.Start();
while (true)
{
NetworkMessageReader netMessageReader = new NetworkMessageReader(tcpListener.AcceptTcpClient());
netMessageReader.ReadCompleted += NetMessageReader_CatanClientAuth_Request_ReadCompleted;
netMessageReader.ReadError += (obj, e) => { e.TcpClient.Close(); };
netMessageReader.ReadAsync();
}
}
catch (SocketException socketEx)
{
if (socketEx.SocketErrorCode == SocketError.Interrupted)
{
// Tcplistener wurde geschlossen. Durch Stop()
while (true)
{
Console.ReadLine(); // Server läuft weiter ...
}
}
else
{
iLogicLayer.ThrowException(socketEx);
}
}
catch (Exception ex)
{
iLogicLayer.ThrowException(ex);
}
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out ClientOSTimestamp);
return(isOk);
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out AcknowledgedServerSimulationTickNumber);
return(isOk);
}
private void handleVoiceMessage(VoiceMessage voiceMessage, TcpClient sender, NetworkMessageReader networkMessageReader)
{
if (voiceMessage.Sender.Id.HasValue && existsClientInClientListByTcpClientAndId(sender, voiceMessage.Sender.Id.Value))
{
Logger.log.Info($"Voicemessage received from {getServerBroadcastClientByTcpClient(sender)}");
var clientsToRemove = new List <TcpClient>();
foreach (ServerBroadcastClient client in clients.Where(client => !client.Client.Id.Value.Equals(voiceMessage.Sender.Id.Value)).ToList())
{
// sendBroadcast
try
{
NetworkMessageWriter messageWriter = new NetworkMessageWriter(client.TcpClient);
messageWriter.WriteError += (_ob, _e) => { Logger.log.Error(_e); };
messageWriter.WriteAsync(voiceMessage);
}
catch (Exception ex)
{
// connection error? client is offline?
Logger.log.Error(ex);
clientsToRemove.Add(client.TcpClient);
}
}
removeClientsFromListByTcpClients(clientsToRemove);
}
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out PlayerId) &&
message.Read(out SimulationTickNumber);
return(isOk);
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out ClientOSTimeStamp) &&
message.Read(out ServerWorldTimeInTicks);
return(isOk);
}
public bool TryReadHeader(NetworkMessageReader message, out ushort arraySize)
{
//arraySize = 0;
bool isOk = true &&
message.Read(out arraySize);
return(isOk);
}
public bool TryReadNextArrayItem(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out SimulationTickNumber) &&
message.Read(out NetworkEntityId) &&
message.ReadEnumFromByte(out InputActionType);
return(isOk);
}
public bool TryReadNextArrayItem(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out PlayerInputSequenceNumber) &&
message.Read(out MoveInput) &&
message.Read(out JumpRequestedInput);
return(isOk);
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out AcknowledgedLastReceivedPlayerInputSequenceNumber) &&
message.Read(out LastAppliedServerPlayerInputSequenceNumber) &&
message.Read(out ServerSimulationTickNumber);
return(isOk);
}
public bool TryReadNextArrayItem(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out NetworkEntityId) &&
message.Read(out Position) &&
message.Read(out YawOrientation) &&
message.Read(out MoveSpeedDecimalPercentage) &&
message.Read(out CurrentMoveInputVelocity) &&
message.Read(out PhysicsEngineLinearVelocity) &&
message.Read(out IsGrounded);
return(isOk);
}
public void OnDataReceived(byte[] buffer, int dataSize)
{
if (_message == null)
{
_message = new NetworkMessageReader();
}
if (_message.Read(buffer, dataSize))
{
var bytes = _message.Payload();
var output = Encoding.UTF8.GetString(bytes);
Debug.Log($"Client {_id}: got: {output}");
_message = null;
}
}
public void OnDataReceived(byte[] buffer, int dataSize)
{
if (_message == null)
{
_message = new NetworkMessageReader();
}
if (_message.Read(buffer, dataSize))
{
var bytes = _message.Payload();
var output = Encoding.UTF8.GetString(bytes);
Debug.Log(output);
//NetworkCommander.ReceiveSyncedCommand(output);
NetworkCommander.ReceiveSyncMessages(output);
_message = null;
}
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true &&
message.Read(out CanJoinGame);
if (CanJoinGame)
{
isOk = isOk &&
message.Read(out InGameSceneAssetId);
}
else
{
isOk = isOk &&
message.Read(out ErrorMessage);
}
return(isOk);
}
/// <summary>
/// Receive a message from the connected client, and delegates it to listeners.
/// </summary>
/// <returns>Received NetworkMessage.</returns>
private NetworkMessage StreamToMessage()
{
// Read message length
byte[] lBytes = new byte[4];
clientStream.Read(lBytes, 0, 4);
int l = BytesToInt(lBytes);
// Read message
byte[] bytes = new byte[l];
clientStream.Read(bytes, 0, bytes.Length);
// Deserialize message
string data = Encoding.UTF8.GetString(bytes);
NetworkMessage message = null;
try
{
message = NetworkMessageReader.Deserialize(data);
}
catch (Exception exc)
{
Console.WriteLine("Skipped null message");
return(null);
}
// Delegate event.
if (OnMessageReceived != null)
{
OnMessageReceived.Invoke(this, message);
}
List <Action <NetworkMessage> > actionList;
if (eventList.TryGetValue(message.Message, out actionList))
{
foreach (Action <NetworkMessage> action in actionList)
{
action.Invoke(message);
}
}
return(message);
}
public void AcceptClientsForEver()
{
lock (tcpListener)
{
tcpListener.Start();
}
if (nicNotifier == null)
{
nicNotifier = new NetworkInterfaceStateNotifier(5, localEndPoint.Address);
nicNotifier.NetworkInterfaceIsNotUpEvent += NicNotifier_NetworkInterfaceIsNotUpEvent;
nicNotifier.Start();
}
while (true)
{
try
{
Logger.log.Info("Waiting for clients ...");
NetworkMessageReader messageReader = new NetworkMessageReader(tcpListener.AcceptTcpClient());
messageReader.ReadCompleted += MessageReader_ReadCompleted;
messageReader.ReadError += MessageReader_ReadError;
messageReader.OnErrorStopReadingAndCloseClient = true;
messageReader.ReadAsync(true);
}
catch (Exception ex)
{
Logger.log.Error(ex);
bool needTcpListenerRestart = true;
while (needTcpListenerRestart)
{
while (restartTcpListener())
{
needTcpListenerRestart = false;
break;
}
Thread.Sleep(5000); // wait 5 sec
}
}
}
}
public void OnDataReceived(byte[] buffer, int dataSize)
{
if (_message == null)
{
_message = new NetworkMessageReader();
}
if (_message.Read(buffer, dataSize))
{
var bytes = _message.Payload();
var output = Encoding.UTF8.GetString(bytes);
Debug.Log($"Server: Received: {output}");
if (output.Contains("PING"))
{
BroadcastToClients("PING");
}
_message = null;
}
}
/// <summary>
/// Checks if the server sent any message.
/// </summary>
private void ReceiveMessages()
{
// The client is null or not connected anymore
// Stop running the thread
if (client == null || !client.Connected)
{
runningThread = false;
return;
}
while (stream.DataAvailable)
{
// Try to read the message.
try
{
byte[] lBytes = new byte[4];
stream.Read(lBytes, 0, 4);
int l = BytesToInt(lBytes);
byte[] bytes = new byte[l];
stream.Read(bytes, 0, bytes.Length);
// Log data.
string data = Encoding.UTF8.GetString(bytes);
NetworkMessage networkMessage = NetworkMessageReader.Deserialize(data);
if (networkMessage == null)
{
Debug.LogError("The received message object could not be deserialized to NetworkMessage.");
return;
}
AddReceivedMessages(networkMessage);
}
catch (Exception e)
{
throw e;
}
}
}
// TODO Threadsicher???!!!!
public void Connect()
{
tcpClient = new TcpClient();
messageReader = new NetworkMessageReader(tcpClient);
messageWriter = new NetworkMessageWriter(tcpClient);
messageReader.OnErrorStopReadingAndCloseClient = true;
messageWriter.OnErrorStopWritingAndCloseClient = true;
messageReader.ReadCompleted += MessageReader_ReadCompleted;
messageReader.ReadError += MessageReader_ReadError;
messageWriter.WriteError += MessageWriter_WriteError;
IsConnected = false;
IsConnecting = true;
var config = AppConfiguration.ReadConfig();
try
{
tcpClient.BeginConnect(config.ServerIP, config.ServerPort, tcpClientConnectCallback, config);
}
catch (Exception ex)
{
IsConnected = false;
IsConnecting = false;
throw ex;
}
finally
{
if (autoReconnectTimer == null)
{
autoReconnectTimer = new System.Threading.Timer(autoReconnectTimerCallback, null, autoReconnectTimerIntervalInMs, autoReconnectTimerIntervalInMs);
}
}
}
public bool TryRead(NetworkMessageReader message)
{
bool isOk = true;
return(isOk);
}
private void handleConnectMessage(ConnectMessage connectMessage, TcpClient sender, NetworkMessageReader messageReader)
{
try
{
if (connectMessage.BroadCastClient == null)
{
// close
sender.Close();
return;
}
if (connectMessage.BroadCastClient.Name != null && connectMessage.BroadCastClient.Name.Length > 2)
{
var newClient = new BroadcastClient(connectMessage.BroadCastClient.Name, ++lastClientID);
lock (clients)
{
clients.Add(new ServerBroadcastClient(newClient, sender));
}
NetworkMessageWriter messageWriter = new NetworkMessageWriter(sender);
messageWriter.OnErrorStopWritingAndCloseClient = true;
messageWriter.WriteError += MessageWriter_WriteError;
// send client ConnectMessage Message
connectMessage.Connected = true;
connectMessage.BroadCastClient = newClient; // modified ..
messageWriter.WriteAsync(connectMessage);
Logger.log.Info($"client connected {connectMessage.BroadCastClient}");
}
else
{
Logger.log.Warn("BroadCastClient name not ok");
// close
sender.Close();
}
}
catch (Exception ex)
{
Logger.log.Error(ex);
}
}
