public void WriteTo(NetworkMessageWriter message)
{
message.Write(ServerMessageType.DespawnRemotePlayer);
message.Write(PlayerId);
message.Write(SimulationTickNumber);
}
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);
}
}
private void sendMessage(NetworkMessage message)
{
NetworkMessageWriter networkWriter = new NetworkMessageWriter(tcpClient);
networkWriter.WriteError += (_ob, _e) => { Logger.log.Error(_e); };
networkWriter.WriteAsync(message);
}
private void NetMessageReader_CatanClientAuth_Request_ReadCompleted(object obj, NetworkMessageReaderReadCompletedEventArgs e)
{
lock (catanClients)
{
try
{
CatanClientAuthenticationRequestMessage authMessage = e.NetworkMessage as CatanClientAuthenticationRequestMessage;
// Checking auth
if (iLogicLayer.IsAuthenticationRequestMessageOk(authMessage))
{
NetworkMessageWriter netMessageWriter = new NetworkMessageWriter(e.TcpClient);
netMessageWriter.WriteError += (o, ee) => { ee.TcpClient.Close(); };
netMessageWriter.WriteCompleted += NetMessageWriter_CatanClientAuth_Response_WriteCompleted;
netMessageWriter.WriteAsync(new CatanClientAuthenticationResponseMessage(authMessage));
}
else
{
e.TcpClient.Close(); // Client wird rausgeworfen, wenn Pass falsch ist !!
}
}
catch (Exception ex)
{
e.TcpClient.Close();
iLogicLayer.ThrowException(ex);
}
}
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ServerMessageType.SnaphotUpdates);
message.Write(AcknowledgedLastReceivedPlayerInputSequenceNumber);
message.Write(LastAppliedServerPlayerInputSequenceNumber);
message.Write(ServerSimulationTickNumber);
}
public ServerNetworkHandler(NetworkSystem networkSystem)
{
_networkSystem = networkSystem;
_netManager = new NetManager(this)
{
AutoRecycle = true,
DisconnectTimeout = ConnectionTimeoutInMilliseconds,
};
_networkMessageWriter = new NetworkMessageWriter(new NetDataWriter());
}
public NetworkEntityProcessor()
{
_networkMessageWriter = new NetworkMessageWriter(new LiteNetLib.Utils.NetDataWriter());
_serverPlayerManager = new ServerPlayerManager(4, this);
_clientPlayerManager = new ClientPlayerManager(this);
Order = -20000; // Ensure this occurs before other processors
// Not using Enabled property, because that completely disables the processor, where it doesn't even pick up newly added entities
IsEnabled = true;
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ServerMessageType.SpawnLocalPlayer);
message.Write(PlayerId);
message.Write(SimulationTickNumber);
message.Write(PlayerName);
message.Write(Position);
message.Write(Rotation);
}
public void WriteNextArrayItem(NetworkMessageWriter message)
{
message.Write(NetworkEntityId);
message.Write(Position);
message.Write(YawOrientation);
message.Write(MoveSpeedDecimalPercentage);
message.Write(CurrentMoveInputVelocity);
message.Write(PhysicsEngineLinearVelocity);
message.Write(IsGrounded);
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ServerMessageType.ClientJoinGameResponse);
message.Write(CanJoinGame);
if (CanJoinGame)
{
message.Write(InGameSceneAssetId);
}
else
{
message.Write(ErrorMessage);
}
}
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);
}
}
public void SendBroadcastMessage(NetworkMessage networkMessage)
{
try
{
//getDisconnectedClientConnections();
foreach (CatanClient catanClient in catanClients)
{
NetworkMessageWriter netMessageWriter = new NetworkMessageWriter(catanClient.TcpClient);
netMessageWriter.WriteCompleted += NetMessageWriter_BroadcastMessage_WriteCompleted;
netMessageWriter.WriteError += NetMessageWriter_BroadcastMessage_WriteError;
netMessageWriter.WriteAsync(networkMessage);
}
}
catch (CatanClientDisconnectedException ex)
{
}
catch (Exception ex)
{
}
}
internal void UpdatePendingPlayerStates(NetworkMessageWriter networkMessageWriter)
{
var networkAssetDatabase = _networkEntityProcessor._networkAssetDatabase;
var assetDefinitions = GetNetworkAssetDefinitions();
//lock (PendingPlayers)
for (int i = 0; i < PendingRemotePlayers.Count; i++)
{
ref var pendingPlayer = ref PendingRemotePlayers.Items[i];
switch (pendingPlayer.PendingPlayerState)
{
case PendingPlayerState.JustConnected:
{
pendingPlayer.PendingPlayerState = PendingPlayerState.LoadingScene;
networkMessageWriter.Reset();
var joinGameResponseMsg = new ClientJoinGameResponseMessage
{
CanJoinGame = true,
InGameSceneAssetId = networkAssetDatabase.GetAssetIdFromUrlReference(assetDefinitions.InGameScene),
};
joinGameResponseMsg.WriteTo(networkMessageWriter);
pendingPlayer.Connection.Send(networkMessageWriter, SendNetworkMessageType.ReliableOrdered);
}
break;
case PendingPlayerState.LoadingScene:
// Keep waiting for the player to load the scene
// TODO: maybe do a timeout and/or ping check?
break;
case PendingPlayerState.Ready:
OnNewRemotePlayerReady(pendingPlayer.PlayerId, pendingPlayer.PlayerName, pendingPlayer.Connection, networkMessageWriter);
break;
default:
break;
}
}
// 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 void WriteNextArrayItem(NetworkMessageWriter message)
{
message.Write(SimulationTickNumber);
message.Write(NetworkEntityId);
message.Write((byte)InputActionType);
}
public void WriteHeader(NetworkMessageWriter message, ushort arraySize)
{
//message.Write((byte)EntityUpdateType.InputAction);
message.Write(arraySize);
}
public void WriteHeader(NetworkMessageWriter message, ushort arraySize)
{
message.Write(arraySize);
}
internal void SendClientInputPredictionsToServer(SimulationTickNumber currentSimTickNumber, NetworkMessageWriter networkMessageWriter)
{
for (int playerIdx = 0; playerIdx < _localPlayers.Count; playerIdx++)
{
ref var player = ref _localPlayers.Items[playerIdx];
var inputSnapshotsComp = player.InputSnapshotsComponent;
PlayerUpdateMessage playerUpdateMsg = default;
var pendingInputs = inputSnapshotsComp.PendingInputs;
// Need to limit the number of input, eg. if there's a large delay in server ack response,
// then most likely it has lost some of our older input. Probably should be a config setting?
const int MaxPendingPlayerInputs = GameConfig.PhysicsSimulationRate * 20; // 20s worth of input
const int MaxSendPlayerInputs = 10; // We will only send 10 inputs max in a single packet, and accept the fact that older inputs may be lost
if (pendingInputs.Count >= MaxPendingPlayerInputs)
{
pendingInputs.RemoveRange(0, pendingInputs.Count - MaxPendingPlayerInputs + 1);
}
// Append the latest input
var findSnapshotResult = inputSnapshotsComp.SnapshotStore.TryFindSnapshot(currentSimTickNumber);
Debug.Assert(findSnapshotResult.IsFound);
pendingInputs.Add(findSnapshotResult.Result);
int sendInputCount = Math.Min(pendingInputs.Count, MaxSendPlayerInputs);
// At most, only send the last 10 inputs (ie. the current inputs) to not blow out the packet size.
int inputIndexOffset = pendingInputs.Count - sendInputCount;
for (int i = 0; i < sendInputCount; i++)
{
int inputIndex = i + inputIndexOffset;
if (pendingInputs[inputIndex].PlayerInputSequenceNumber > inputSnapshotsComp.ServerLastAcknowledgedPlayerInputSequenceNumber)
{
inputIndexOffset += i;
sendInputCount -= i;
break;
}
}
networkMessageWriter.Reset();
playerUpdateMsg.AcknowledgedServerSimulationTickNumber = player.NetworkEntityComponent.LastAcknowledgedServerSimulationTickNumber;
playerUpdateMsg.WriteTo(networkMessageWriter);
PlayerUpdateInputMessage playerUpdateInputsMsg = default;
playerUpdateInputsMsg.WriteHeader(networkMessageWriter, (ushort)sendInputCount);
for (int i = 0; i < sendInputCount; i++)
{
int inputIndex = i + inputIndexOffset;
ref var curInputData = ref pendingInputs.Items[inputIndex];
playerUpdateInputsMsg.PlayerInputSequenceNumber = curInputData.PlayerInputSequenceNumber;
playerUpdateInputsMsg.MoveInput = curInputData.MoveInput;
playerUpdateInputsMsg.JumpRequestedInput = curInputData.IsJumpButtonDown;
playerUpdateInputsMsg.WriteNextArrayItem(networkMessageWriter);
#if DEBUG
//if (curInputData.MoveInput.LengthSquared() > 0)
//{
// _networkEntityProcessor.DebugWriteLine($"Cln SendInput Move: {curInputData.MoveInput} - PISeqNo: {curInputData.PlayerInputSequenceNumber}");
//}
#endif
}
public void WriteNextArrayItem(NetworkMessageWriter message)
{
message.Write(PlayerInputSequenceNumber);
message.Write(MoveInput);
message.Write(JumpRequestedInput);
}
public void WriteHeader(NetworkMessageWriter message, ushort arraySize)
{
//message.Write((byte)EntityUpdateType.Transform);
message.Write(arraySize);
message.Write(SimulationTickNumber);
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ClientMessageType.ClientJoinGame);
message.Write(PlayerName);
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ClientMessageType.SynchronizeClockRequest);
message.Write(ClientOSTimestamp);
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ClientMessageType.ClientInGameReady);
}
internal void SendToAll(NetworkMessageWriter message, SendNetworkMessageType sendType)
{
_netManager.SendToAll(message, sendType.ToDeliveryMethod());
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ClientMessageType.PlayerUpdate);
message.Write(AcknowledgedServerSimulationTickNumber);
}
void IGameNetworkServerHandler.SendMessageToAllPlayers(NetworkMessageWriter message, SendNetworkMessageType sendType)
{
_serverNetworkHandler.SendToAll(message, sendType);
}
private void OnNewRemotePlayerReady(
SerializableGuid playerId, string playerName, NetworkConnection playerConnection,
NetworkMessageWriter networkMessageWriter)
{
var assetDefinitions = GetNetworkAssetDefinitions();
var assetDatabase = _networkEntityProcessor._networkAssetDatabase;
var networkService = _networkEntityProcessor._networkService;
var content = _networkEntityProcessor._content;
var gameClockManager = _networkEntityProcessor._gameClockManager;
var entityExistenceStates = _networkEntityProcessor._entityExistenceStates;
var gameplayScene = GetGameplayScene();
var simTickNumber = gameClockManager.SimulationClock.SimulationTickNumber;
// Can add to the scene now
Entity playerEntity;
if (networkService.NetworkGameMode == NetworkGameMode.DedicatedServer)
{
var playerPrefabUrl = assetDefinitions.PlayerAssets.ServerRemotePlayer;
var playerPrefab = content.Load(playerPrefabUrl);
playerEntity = playerPrefab.InstantiateSingle();
var networkEntityComp = playerEntity.Get <NetworkEntityComponent>();
networkEntityComp.NetworkEntityId = playerId; // Can just use the same ID
networkEntityComp.OwnerClientId = playerId;
networkEntityComp.AssetId = assetDatabase.GetAssetIdFromUrlReference(playerPrefabUrl);
var networkPlayerComp = playerEntity.Get <NetworkPlayerComponent>();
networkPlayerComp.PlayerName = playerName;
GetPlayerSpawnLocation(gameplayScene, out var spawnPosition, out var spawnRotation);
playerEntity.Transform.Position = spawnPosition;
playerEntity.Transform.Rotation = spawnRotation;
_networkEntityProcessor.AddAndRegisterEntity(playerEntity, gameplayScene, simTickNumber);
}
else
{
// Client game, so has the prefab also player view entity
GetPlayerSpawnLocation(gameplayScene, out var spawnPosition, out var spawnRotation);
playerEntity = _networkEntityProcessor.CreateAndAddClientPlayerEntity(simTickNumber, playerId, playerName, ref spawnPosition, ref spawnRotation, isLocalEntity: false);
}
// Note this must be set AFTER being added to the scene due to snapshot buffer needing to be instantiated by the processor
var movementSnapshotComp = playerEntity.Get <MovementSnapshotsComponent>();
MovementSnapshotsProcessor.CreateNewSnapshotData(simTickNumber, movementSnapshotComp, playerEntity.Transform);
var newPlayer = new ServerActiveRemotePlayer(playerId, playerName, playerEntity, playerConnection);
ActiveRemotePlayers.Add(newPlayer);
var gameManager = GetGameManager();
gameManager.RaisePlayerAddedEvent(playerEntity);
// Notify the new player of all existing players
for (int i = 0; i < ActiveRemotePlayers.Count - 1; i++) // Exclude the last because that's the new player
{
ref var existingPlayer = ref ActiveRemotePlayers.Items[i];
Debug.Assert(existingPlayer.PlayerId != playerId);
var existingPlayerDetails = entityExistenceStates[existingPlayer.PlayerEntity];
var spawnPlayer = new SpawnRemotePlayerMessage
{
PlayerId = existingPlayer.PlayerId,
SimulationTickNumber = existingPlayerDetails.SimulationTickNumberCreated,
PlayerName = existingPlayer.PlayerName,
Position = existingPlayer.PlayerEntity.Transform.Position,
Rotation = existingPlayer.PlayerEntity.Transform.Rotation
};
networkMessageWriter.Reset();
spawnPlayer.WriteTo(networkMessageWriter);
playerConnection.Send(networkMessageWriter, SendNetworkMessageType.ReliableOrdered); // Use Ordered to ensure a player's joined & dropped events are in sequence
}
public void WriteTo(NetworkMessageWriter message)
{
message.Write(ServerMessageType.SynchronizeClockResponse);
message.Write(ClientOSTimeStamp);
message.Write(ServerWorldTimeInTicks);
}
