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);
}
public static void HandlePlayerConnectedMessage(BaseClient client, PlayerConnectedMessage message)
{
logger.Info("Player connected: " + message.Player.Name);
if (client.TeknoServer == null)
{
return;
}
Server.Instance.IOTaskPool.AddMessage(() =>
{
client.TeknoServer.AddPlayer(message.Player);
var record = BanManager.Instance.Bans.FirstOrDefault(x => x.Player != null && (x.Player.IP == message.Player.IP || x.Player.NewHwid == message.Player.NewHwid));
if (record != null)
{
WebhookManager.SendWebhook(message.Player.Name, record.Reason, client.TeknoServer.Hostname, "**Player rejected**", "UiC-BanSystem", Color.Red);
client.Send(new DropClientMessage(message.Player.EntRef, "[UiC] Banned, Reason: " + record.Reason + " Discord: uic.elitesnipers.pw/discord"));
client.Send(new SayToEveryoneMessage($"[UiC] Player ^3{message.Player.Name} ^7Banned ^1permanently^7 ! Reason: ^3{record.Reason}"));
// ServerManager.Instance.KickPlayer(message.Player.NewHwid, record.Reason);
logger.Info("Player banned: " + message.Player.Name + " " + message.Player.NewHwid);
}
});
}
public void ProcessConnectPlayer(ConnectPlayerMessage connectPlayerMessage)
{
int playerId = connectPlayerMessage.PlayerId;
Player player = GetPlayerWithId(playerId);
if (player != null)
{
DisconnectPlayer(player);
}
GameObject playerGO = Instantiate(playerPrefab) as GameObject;
playerGO.name = "Player " + playerId;
player = playerGO.GetComponent <Player> ();
player.endPoint = connectPlayerMessage.EndPoint;
player.Id = playerId;
players.Add(player);
//send all players that a new player has connected
for (int i = 0; i < players.Count; i++)
{
Player playerToSendTo = players [i];
PlayerConnectedMessage playerConnectedMessage = PlayerConnectedMessage.CreatePlayerConnectedMessageToSend(playerToSendTo, playerId);
playerToSendTo.CommunicationManager.SendMessage(playerConnectedMessage);
}
}
// ======================================
// 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);
}
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);
}
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 override void HandleNetworkMessage(Message msg)
{
base.HandleNetworkMessage(msg);
if (msg is PlayerConnectedMessage) //player sends this once connected to send name
{
PlayerConnectedMessage nMsg = msg as PlayerConnectedMessage;
if (GameManager.Instance.GetPlayer(nMsg.playerID) != null) //player name already used, prepare to kick
{
m_ConnectionToAdd = new KeyValuePair <uint, string>(m_NetworkMessageConnectionSource, "");
}
else
{
m_ConnectionToAdd = new KeyValuePair <uint, string>(m_NetworkMessageConnectionSource, nMsg.playerID);
//Send the player connected info to everyone
ClientPlayer cP = GameManager.Instance.ClientPlayer;
if (cP != null)
{
SendMessageToAllExceptPlayer(nMsg.playerID, new PlayerConnectedMessage(nMsg.playerID), SendType.Reliable);
}
//send current players to the connected player
List <Player> players = GameManager.Instance.m_Players;
for (int i = 0; i < players.Count; i++)
{
if (players[i] is ClientPlayer)
{
m_Server.SendMessageToConnection(m_NetworkMessageConnectionSource, new PlayerConnectedMessage(GameManager.Instance.m_PlayerUsername).toBuffer(), SendType.Reliable);
}
else
{
m_Server.SendMessageToConnection(m_NetworkMessageConnectionSource, new PlayerConnectedMessage((players[i] as NetworkedPlayer).playerID).toBuffer(), SendType.Reliable);
}
}
GameManager.Instance.AddPlayer(nMsg.playerID);
Invoke("RealignPlayersAndSend", 0.1f); //need a delay for them to add the player
}
}
if (msg is PlayerUpdateMessage)
{
PlayerUpdateMessage nMsg = msg as PlayerUpdateMessage;
GameManager.Instance.UpdatePlayerInformation(ref nMsg.info, nMsg.playerID);
SendMessageToAllExceptPlayer(nMsg.playerID, nMsg);
}
if (msg is ObstacleModifiedMessage)
{
Debug.Log("Obstacle Modified Message");
ObstacleModifiedMessage nMsg = msg as ObstacleModifiedMessage;
SendMessageToAllExceptPlayer(nMsg.playerID, nMsg, SendType.Reliable);
(GameManager.Instance.m_AllObstacles[(int)nMsg.obstacleID] as IObstacle).InteractedWith(GameManager.Instance.GetPlayer(nMsg.playerID));
}
if (msg is PlayerAttackedPlayerMessage)
{
PlayerAttackedPlayerMessage nMsg = msg as PlayerAttackedPlayerMessage;
SendMessageToAllExceptPlayer(nMsg.attackeePlayerID, nMsg, SendType.Reliable);
GameManager.Instance.PlayerAttacked(nMsg.attackedPlayerID);
}
}
private void BroadcastConnection(int playerId)
{
for (int i = 0; i < players.Count; i++)
{
ServerPlayerController playerToSendTo = players[i];
PlayerConnectedMessage playerConnectedMessage = PlayerConnectedMessage.CreatePCMToSend(playerToSendTo, playerId);
playerToSendTo.CommunicationManager.SendMessage(playerConnectedMessage);
}
}
public void ProcessPlayerConnected(PlayerConnectedMessage message)
{
PlayerNetworkView player = GetPlayerWithId(message.PlayerId);
if (player != null)
{
DisconnectPlayer(player);
}
ConnectPlayer(message.PlayerId);
}
private void ProcessPlayerConnectedMessage(PlayerConnectedMessage message)
{
var playerId = message.PlayerId;
PlayerNetworkView player;
if (_players.TryGetValue(playerId, out player))
{
DisconnectPlayer(player); // Disconnect player if already connected, and reconnect it.
}
ConnectPlayer(playerId);
}
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);
}
}
public void ProcessPlayerConnected(PlayerConnectedMessage playerConnectedMessage)
{
int playerId = playerConnectedMessage.PlayerId;
GameObject playerGO = Instantiate(playerPrefab) as GameObject;
playerGO.name = "Player Network View " + playerId;
PlayerNetworkView player = playerGO.GetComponent <PlayerNetworkView> ();
player.Id = playerId;
if (playerId == this.playerId)
{
localPlayerController = playerGO.AddComponent <PlayerController> ();
}
players.Add(player);
}
public static void RegisterNetworkMessageHandelers()
{
Mod owner = Main.Instance;
MapSendingMessge = new MapSendingMessge();
NetworkManager.AddNetworkMessage(MapSendingMessge, owner);
PlayerConnectMessage = new PlayerConnectedMessage();
NetworkManager.AddNetworkMessage(PlayerConnectMessage, owner);
SpawnPlayerMessage = new SpawnPlayerMessage();
NetworkManager.AddNetworkMessage(SpawnPlayerMessage, owner);
SetLocalPlayerMessage = new SetLocalPlayerMessage();
NetworkManager.AddNetworkMessage(SetLocalPlayerMessage, owner);
DebugMessage = new DebugMessage();
NetworkManager.AddNetworkMessage(DebugMessage, owner);
}
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);
}
protected override void OnWebSocketOpen()
{
var userToken = JwtHelper.DecodeToken(this.Context.QueryString.Get("auth_token"));
var gameIdString = this.Context.QueryString.Get("game_id");
Guid gameId;
if (userToken == null || string.IsNullOrEmpty(gameIdString) || !Guid.TryParse(gameIdString, out gameId))
{
this.Sessions.CloseSession(this.ID, 2000, "Invalid query parameters");
return;
}
if (!this._gameManager.GameHosts.ContainsKey(gameId))
{
this.Sessions.CloseSession(this.ID, 2001, "This game doesn't exist");
return;
}
this._gameHost = this._gameManager.GameHosts[gameId];
this._warsimUser = this._gameManager.GetUser(userToken.UserId);
if (this._warsimUser == null)
{
this.Sessions.CloseSession(this.ID, 2002, "This user isn't connected");
return;
}
var password = this.Context.QueryString.Get("game_password");
var playerType = this.Context.QueryString.Get("player_type");
if (playerType == "spectator")
{
// Start spectating, without telling other players
try
{
this._gameHost.Spectate(this._warsimUser, password);
}
catch (GameException e)
{
this.Sessions.CloseSession(this.ID, e.Code, e.Message);
return;
}
}
else
{
try
{
this._gameHost.Join(this._warsimUser, password);
}
catch (GameException e)
{
this.Sessions.CloseSession(this.ID, e.Code, e.Message);
return;
}
var msg = new PlayerConnectedMessage
{
UserId = this._warsimUser.UserId,
Username = this._warsimUser.Username
};
this.BroadcastToCurrentGame(EventBuilder.Build(msg).Serialize());
}
var statsUpdate = new GameStatisticsUpdate {
UserId = this._warsimUser.UserId
};
if (this.IsGameOwner())
{
statsUpdate.GameCreatedCount++;
}
else
{
statsUpdate.GameJoinedCount++;
}
new UserRepository(new ApplicationDbContext()).UpdateUserStatistics(statsUpdate);
this._warsimUser.GameHostWebSocketId = this.ID;
this._warsimUser.ActiveGameId = this._gameHost.Id;
}
