private Task OnPlayerDisconnected(PlayerDisconnectedMessage message)
{
var plr = _playerManager[message.AccountId];
plr?.Disconnect();
return(Task.CompletedTask);
}
private Message readServerMessage(BitBuffer bf)
{
MessageType messageType = bf.GetEnum <MessageType> ((int)MessageType.TOTAL);
Message serverMessage = null;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
serverMessage = PlayerConnectedMessage.CreatePlayerConnectedMessageToReceive();
break;
case MessageType.PLAYER_DISCONNECTED:
serverMessage = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToReceive();
break;
case MessageType.SNAPSHOT:
serverMessage = new SnapshotMessage();
break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
serverMessage = AckReliableMessage.CreateAckReliableMessageMessageToReceive();
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
serverMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToReceive();
break;
default:
Debug.LogError("Got a Server message that cannot be understood");
return(null);
}
serverMessage.Load(bf);
return(serverMessage);
}
// ======================================
// Server message reception
// ======================================
private static Message ReceiveServerMessage(BitBuffer bitBuffer)
{
var messageType = bitBuffer.GetEnum <MessageType>((int)MessageType.TOTAL);
Message message;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
message = PlayerConnectedMessage.CreatePlayerConnectedMessageToReceive();
break;
case MessageType.PLAYER_DISCONNECTED:
message = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToReceive();
break;
case MessageType.SNAPSHOT:
message = new SnapshotMessage();
break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
message = AckReliableMessage.CreateAckReliableMessageMessageToReceive();
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
message = AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToReceive();
break;
default:
return(null); // Return null if the message is not a "from server" type
}
message.Load(bitBuffer);
return(message);
}
Message ReadServerMessage(BitBuffer bitBuffer)
{
MessageType messageType = bitBuffer.GetEnum <MessageType>((int)MessageType.TOTAL);
Message serverMessage = null;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
serverMessage = PlayerConnectedMessage.CreatePCMToReceive(); break;
case MessageType.PLAYER_DISCONNECTED:
serverMessage = PlayerDisconnectedMessage.CreatePDMToReceive(); break;
case MessageType.SNAPSHOT:
serverMessage = new SnapshotMessage(); break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
serverMessage = AckReliableMessage.CreateAckReliableMessageToReceive(); break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
serverMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSEFMToReceive(); break;
default:
Debug.LogError("Unknown server message received.");
return(null);
}
serverMessage.Load(bitBuffer);
return(serverMessage);
}
private void ProcessPlayerDisconnectedMessage(PlayerDisconnectedMessage message)
{
PlayerNetworkView player;
if (_players.TryGetValue(message.PlayerId, out player))
{
DisconnectPlayer(player);
}
}
public static Message decipherMessage(byte[] msgBytes)
{
if (BitConverter.IsLittleEndian)
{
//Array.Reverse(msgBytes);
}
Message msg;
byte[] eventTypeBytes = new byte[2];
Buffer.BlockCopy(msgBytes, 0, eventTypeBytes, 0, 2);
ushort sho = BitConverter.ToUInt16(eventTypeBytes, 0);
NetworkEvent eventType = (NetworkEvent)sho;
switch (eventType)
{
case NetworkEvent.StartGame:
msg = new GameStartMessage(msgBytes);
break;
case NetworkEvent.PlayerUpdateInfo:
msg = new PlayerUpdateMessage(msgBytes);
break;
case NetworkEvent.PlayerConnected:
msg = new PlayerConnectedMessage(msgBytes);
break;
case NetworkEvent.PlayerDisconnected:
msg = new PlayerDisconnectedMessage(msgBytes);
break;
case NetworkEvent.ObstacleGenerated:
msg = new ObstacleGeneratedMessage(msgBytes);
break;
case NetworkEvent.PlayerFellBehind:
msg = new PlayerFellBehindMessage(msgBytes);
break;
case NetworkEvent.ObstacleModified:
msg = new ObstacleModifiedMessage(msgBytes);
break;
case NetworkEvent.PlayerWonRace:
msg = new PlayerWonMessage(msgBytes);
break;
case NetworkEvent.PlayerAttackPlayer:
msg = new PlayerAttackedPlayerMessage(msgBytes);
break;
default:
throw new Exception("oops " + eventType);
}
return(msg);
}
public void ProcessPlayerDisconnected(PlayerDisconnectedMessage message)
{
PlayerNetworkView player = GetPlayerWithId(message.PlayerId);
if (player != null)
{
DisconnectPlayer(player);
}
}
public void PlayerDisconnected(uint connection, string playerID)
{
PlayerDisconnectedMessage dMsg = new PlayerDisconnectedMessage(playerID);
SendMessageToAllPlayers(dMsg, SendType.Reliable);
GameManager.Instance.RemovePlayer(playerID);
m_Connections.Remove(connection);
m_Server.CloseConnection(connection);
RealignPlayersAndSend();
}
public void ProcessPlayerDisconnected(PlayerDisconnectedMessage playerDisconnectedMessage)
{
int playerId = playerDisconnectedMessage.PlayerId;
PlayerNetworkView player = GetPlayerWithId(playerId);
if (player != null)
{
players.Remove(player);
Destroy(player);
}
}
protected override void OnWebSocketClose(CloseEventArgs e)
{
this._warsimUser.GameHostWebSocketId = string.Empty;
this._warsimUser.ActiveGameId = Guid.Empty;
// Owner has manually ended the game, the game is already erased from memory
if (e.Code == 2008)
{
return;
}
// If the user is a spectator
if (this._gameHost.Spectators.ContainsKey(this._warsimUser.UserId))
{
this._gameHost.Spectators.TryRemove(this._warsimUser.UserId, out this._warsimUser);
}
// If the user is a player
var oldGameOwnerId = this._gameHost.OwnerId;
var gameStillActive = this._gameHost.Leave(this._warsimUser);
if (gameStillActive)
{
this._gameHost.Map.ResetStartArrow(this._warsimUser.UserId);
this._gameHost.Map.DeselectUserObjects(this._warsimUser.UserId);
if (this._gameHost.Mode == GameMode.Simulation)
{
this._gameHost.Map.RemoveUserRobot(this._warsimUser.UserId);
}
var disconnectedMsg = new PlayerDisconnectedMessage
{
UserId = this._warsimUser.UserId,
Username = this._warsimUser.Username
};
this.BroadcastToCurrentGame(EventBuilder.Build(disconnectedMsg).Serialize());
// This means the owner of the game has changed
if (oldGameOwnerId == this._warsimUser.UserId)
{
var newOwnerMsg = new NewGameOwnerMessage();
var newOwner = this._gameManager.GetUser(this._gameHost.OwnerId);
// Send a message to tell the new game owner
this.Sessions.SendTo(EventBuilder.Build(newOwnerMsg).Serialize(), newOwner.GameHostWebSocketId);
}
}
else
{
this._gameManager.EndGame(this._gameHost);
}
}
public override void HandleNetworkMessage(Message msg)
{
base.HandleNetworkMessage(msg);
if (msg is GameStartMessage)
{
GameStartMessage nMsg = msg as GameStartMessage;
ConnectionStatus cStat = new ConnectionStatus();
m_Server.GetQuickConnectionStatus(m_Connection, cStat);
uniformTimeOffset = ((nMsg.uniformTime.Ticks / TimeSpan.TicksPerSecond) + (((float)cStat.ping) * 0.01f)) - (DateTime.UtcNow.Ticks / TimeSpan.TicksPerSecond);
GameManager.Instance.StartGameInSeconds(nMsg.timeAfterToSpawn + uniformTimeOffset);
}
if (msg is PlayerConnectedMessage)
{
PlayerConnectedMessage nMsg = msg as PlayerConnectedMessage;
NetworkedPlayer p = GameManager.Instance.AddPlayer(nMsg.playerID);
p.playerID = nMsg.playerID;
}
else if (msg is PlayerDisconnectedMessage)
{
PlayerDisconnectedMessage nMsg = msg as PlayerDisconnectedMessage;
GameManager.Instance.RemovePlayer(nMsg.playerID);
}
else if (msg is PlayerUpdateMessage)
{
PlayerUpdateMessage nMsg = msg as PlayerUpdateMessage;
GameManager.Instance.UpdatePlayerInformation(ref nMsg.info, nMsg.playerID);
}
else if (msg is ObstacleGeneratedMessage)
{
ObstacleGeneratedMessage nMsg = msg as ObstacleGeneratedMessage;
TileManager.Instance.SpawnObstacle(nMsg.itemID, nMsg.itemPos, nMsg.itemType);
}
else if (msg is ObstacleModifiedMessage)
{
ObstacleModifiedMessage nMsg = msg as ObstacleModifiedMessage;
(GameManager.Instance.m_AllObstacles[(int)nMsg.obstacleID] as IObstacle).InteractedWith(GameManager.Instance.GetPlayer(nMsg.playerID));
}
else if (msg is PlayerFellBehindMessage)
{
PlayerFellBehindMessage nMsg = msg as PlayerFellBehindMessage;
GameManager.Instance.PlayerFellBehind(nMsg.playerID);
}
else if (msg is PlayerWonMessage)
{
PlayerWonMessage nMsg = msg as PlayerWonMessage;
GameManager.Instance.PlayerHasWonGame(GameManager.Instance.GetPlayer(nMsg.playerID));
}
else if (msg is PlayerAttackedPlayerMessage)
{
PlayerAttackedPlayerMessage nMsg = msg as PlayerAttackedPlayerMessage;
GameManager.Instance.PlayerAttacked(nMsg.attackedPlayerID);
}
}
void OnServerLostClient(NetworkMessage netMsg)
{
dWin.Text("Server Disconnected from client " + netMsg.conn.connectionId);
players.Remove(netMsg.conn.connectionId);
dWin.Text(GetPlayerStats());
var playerDisconnectedMessage = new PlayerDisconnectedMessage();
playerDisconnectedMessage.id = netMsg.conn.connectionId;
NetworkServer.SendToAll(NetworkMessages.PlayerDisconnected, playerDisconnectedMessage);
}
private Task OnPlayerDisconnected(PlayerDisconnectedMessage message)
{
var plr = _playerManager[message.AccountId];
if (plr == null)
{
_logger.Warning("<OnPlayerDisconnected> Cant find player={Id}", message.AccountId);
return(Task.CompletedTask);
}
plr.Disconnect();
return(Task.CompletedTask);
}
private void HandlePlayerDisconnectedMessage(NetIncomingMessage im)
{
var message = new PlayerDisconnectedMessage(im);
if (TileGrid.GameState == GameStates.Lobby)
{
bannerManager.RemoveLobbyBanner(message.Pos);
if (this.IsHost)
{
OnPlayerDisconnect(message.Name, message.Color, message.Pos);
}
}
}
void ProcessDisconnectPlayer(DisconnectPlayerMessage disconnectPlayerMessage)
{
Player player = GetPlayerWithEndPoint(disconnectPlayerMessage.From);
if (player != null)
{
DisconnectPlayer(player);
for (int i = 0; i < players.Count; i++)
{
Player playerToSendTo = players [i];
PlayerDisconnectedMessage playerDisconnectedMessage = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToSend(playerToSendTo, player.Id);
playerToSendTo.CommunicationManager.SendMessage(playerDisconnectedMessage);
}
}
}
public static void HandlePlayerDisconnectedMessage(BaseClient client, PlayerDisconnectedMessage message)
{
if (client.TeknoServer == null)
{
return;
}
var player = client.TeknoServer.Players.FirstOrDefault(x => x.EntRef == message.entRef);
if (player != null)
{
logger.Info("Player disconnected: " + player.Name);
client.TeknoServer.RemovePlayer(message.entRef);
}
}
public void RemoveClientOrAgent(ulong clientId)
{
var client = JoiningAgents.Where(q => q.ID == clientId).FirstOrDefault();
if (client != null)
{
JoiningAgents.Remove(client);
}
var agent = Agents.Where(q => q.Client.ID == clientId).FirstOrDefault();
if (agent != null)
{
Agents.Remove(agent);
var message = new PlayerDisconnectedMessage(agent.PlayerId);
SendMessageToGameMaster(message.Serialize());
}
}
void LostClient(NetworkMessage netMsg)
{
Debug.Log("Lost client...");
if (players[netMsg.conn.connectionId].GetObject() != null)
{
Destroy(players[netMsg.conn.connectionId].GetObject());
}
players.Remove(netMsg.conn.connectionId);
if (lobbyGui != null)
{
lobbyGui.UpdateUI(players);
}
// broadcast
var playerDisconnectedMessage = new PlayerDisconnectedMessage();
playerDisconnectedMessage.id = netMsg.conn.connectionId;
NetworkServer.SendToAll(CustomNetMsg.PlayerDisconnected, playerDisconnectedMessage);
}
public void HandlePlayerDisconnectedRequest(PlayerDisconnectedMessage playerDisconnected)
{
ConsoleWriter.Show("Player disconnected...");
UnregisterPlayer(playerDisconnected.PlayerID);
}
Message ReadServerMessage(BitBuffer bitBuffer)
{
MessageType messageType = bitBuffer.GetEnum <MessageType> ((int)MessageType.TOTAL);
Message serverMessage = null;
switch (messageType)
{
case MessageType.PLAYER_CONNECTED:
serverMessage = PlayerConnectedMessage.CreatePlayerConnectedMessageToReceive();
break;
case MessageType.PLAYER_DISCONNECTED:
serverMessage = PlayerDisconnectedMessage.CreatePlayerDisconnectedMessageToReceive();
break;
case MessageType.SNAPSHOT:
serverMessage = new SnapshotMessage();
break;
case MessageType.ACK_RELIABLE_MAX_WAIT_TIME:
Debug.Log("Client::got ack reliable wait time ");
serverMessage = AckReliableMessage.CreateAckReliableMessageMessageToReceive();
break;
case MessageType.ACK_RELIABLE_SEND_EVERY_PACKET:
serverMessage = AckReliableSendEveryFrameMessage.CreateAckReliableSendEveryFrameMessageMessageToReceive();
break;
default:
Debug.LogError("Got a server message that cannot be understood");
return(null);
}
serverMessage.Load(bitBuffer);
if (serverMessage.Reliability == ReliabilityType.RELIABLE_MAX_WAIT_TIME)
{
if (serverMessage.ReliabilityId == (LastReceivedReliableMessageId + 1))
{
//accept it... valid message since its +1 since the last received
//send to the sender that its reliable message has been received
outMessages.Add(AckReliableMessage.CreateAckReliableMessageMessageToSend(serverMessage.ReliabilityId));
LastReceivedReliableMessageId = serverMessage.ReliabilityId;
}
else
{
//we need to discard it... either its been already processed or out of order
return(null);
}
}
else if (serverMessage.Reliability == ReliabilityType.RELIABLE_SEND_EVERY_PACKET)
{
if (serverMessage.ReliabilityId > LastReceivedSendInEveryFramePacketMessageId)
{
//set the last "reliable send in every packet" message id.. it will get sent to the server on the next packet
LastReceivedSendInEveryFramePacketMessageId = serverMessage.ReliabilityId;
Debug.Log("Client::lastReceivedSendInEveryFramePacketMessageId = " + lastReceivedSendInEveryFramePacketMessageId);
}
else
{
//discard
return(null);
}
}
return(serverMessage);
}