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; }