public override async Task OnConnectedAsync() { LobbyUser lobbyUser = null; if (Context.User.Identity.IsAuthenticated) { var encodedBlockList = Context.User.FindFirst("BlockList"); var blockList = encodedBlockList != null && !string.IsNullOrEmpty(encodedBlockList.Value) ? JsonConvert.DeserializeObject <List <string> >(encodedBlockList.Value) : new List <string>(); var userData = Context.User.FindFirst("UserData"); lobbyUser = new LobbyUser { ConnectionId = Context.ConnectionId, Name = Context.User.Identity.Name, BlockList = blockList, UserData = userData.Value ?? string.Empty }; await lobbyService.NewUserAsync(lobbyUser); } await Clients.Caller.UserList(lobbyService.GetOnlineUsersForLobbyUser(lobbyUser).Select(u => u.Name).ToList()); await Clients.Caller.GameList(lobbyService.GetGameListForLobbyUser(lobbyUser)); }
public void PeerAdded(LobbyUser user) { lock (AddedUsers) AddedUsers.Add(user); CheckAlive(); }
protected void CheckConnection(LobbyUser user) { if (user.GetAttributeB("ValidAuthentication") == true && user.GetAttributeB("ValidConnection") == true) { user.AuthenticationStatus = LobbyUser.AuthenticationStatusTypes.Valid; Host.PeerAuthenticated(user); } }
public static string DisplayUpdate(LobbyUser user) { string msg = CreateJson( new string[] { "username", "ready", "team", "ping" }, new string[] { user.username, user.ready.ToString(), user.team, user.ping.ToString() }); string json = CreateMessage(msg, MessageType.json, "displayUpdate"); return(json); }
public Task NewUserAsync(LobbyUser user) { if (user == null) { throw new ArgumentNullException(nameof(user)); } return(NewUserInternalAsync(user)); }
public List <LobbyUser> GetOnlineUsersForLobbyUser(LobbyUser user = null) { if (user == null) { return(UsersByConnectionId.Values.ToList()); } return(UsersByConnectionId.Values.Where(u => !user.BlockList.Contains(u.Name) && !u.BlockList.Contains(user.Name)).ToList()); }
protected override void HandleUserMessage(LobbyUser user, NetworkMessage message) { base.HandleUserMessage(user, message); // process auth messages if (message as AuthenticationRequest != null) { ProcessAuthenticationRequest(user, message as AuthenticationRequest); } }
protected override void HandleUserAdded(LobbyUser user) { base.HandleUserAdded(user); user.AuthenticationStatus = LobbyUser.AuthenticationStatusTypes.Pending; user.SetAttributeB("ValidConnection", false); user.SetAttributeB("ValidAuthentication", false); // start ban checks Bans.Add(user, BanChecksCompleted, null); }
public async Task WhenCalledSetsNodeAndBroadcastsUser() { var user = new LobbyUser { Name = "TestUser", ConnectionId = Guid.NewGuid().ToString() }; await Service.NewUserAsync(user); Assert.AreEqual(LobbyOptions.Value.NodeName, user.Node); SubscriberMock.Verify(s => s.PublishAsync(It.Is <RedisChannel>(channel => channel == RedisChannels.NewUser), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.Once); }
public List <LobbyGameListSummary> GetGameListForLobbyUser(LobbyUser lobbyUser) { if (lobbyUser == null) { return(GamesById.Values.Select(g => g.ToGameListSummary()).ToList()); } return(GamesById.Values .Where(g => !g.GetPlayers().Any(player => player.Value.User.HasUserBlocked(lobbyUser) && !lobbyUser.HasUserBlocked(player.Value.User))) .Select(g => g.ToGameListSummary()).ToList()); }
public static LobbyUser GenerateLobbyUser() { Random random = new Random(); string username = "******" + random.Next(10000).ToString(); bool ready = false; string team = random.Next(2) == 0 ? "red" : "blue"; int ping = random.Next(4, 200); LobbyUser newUser = new LobbyUser(username, ready, team, ping); return(newUser); }
public async Task WhenCalledTwiceDoesNotBroadcastsUser() { var user = new LobbyUser { Name = "TestUser", ConnectionId = Guid.NewGuid().ToString() }; await Service.NewUserAsync(user); await Service.NewUserAsync(user); SubscriberMock.Verify( s => s.PublishAsync(It.Is <RedisChannel>(channel => channel == RedisChannels.NewUser), It.IsAny <RedisValue>(), It.IsAny <CommandFlags>()), Times.AtMostOnce); }
public void Add(LobbyUser user, EventHandler <BanProcessrUserArgs> cb, object token) { BanCheckUser bcu = new BanCheckUser(); bcu.User = user; bcu.Token = token; bcu.Callback += cb; lock (CheckingUsers) CheckingUsers.Add(bcu); CheckAlive(); }
protected void ProcessAuthenticationRequest(LobbyUser user, AuthenticationRequest request) { if (request == null) { return; } user.SetAttributeB("ValidAuthentication", false); user.GlobalUserID = request.UserID; user.GlobalToken = request.Token; user.DisplayName = request.DisplayName; Host.SendValidationRequest(user.UserID, request.Token, user, ArgChecksCallback); }
private async Task NewUserInternalAsync(LobbyUser user) { if (UsersByConnectionId.ContainsKey(user.ConnectionId)) { Logger.LogError($"Got new user request for '{user.Name}' but already know this user"); return; } user.Node = options.NodeName; UsersByConnectionId.Add(user.ConnectionId, user); await subscriber.PublishAsync(RedisChannels.NewUser, JsonConvert.SerializeObject(user)); }
protected void ArgChecksCallback(object sender, JsonClient.JsonMessageResponceArgs args) { LobbyUser user = args.Token as LobbyUser; if (user == null) { return; } if (args.ResponceMessage as ValidateAuthenticationTokenResponce == null) { user.SocketConnection.Disconnect("Invalid Authentication"); } else { user.SetAttributeB("ValidAuthentication", true); CheckConnection(user); } }
public async Task WhenUserFoundBroadcastsUserDisconnect() { var user = new LobbyUser { Name = "TestUser", ConnectionId = Guid.NewGuid().ToString() }; await Service.NewUserAsync(user); await Service.DisconnectedUserAsync(user.ConnectionId); var jsonUser = JsonConvert.SerializeObject(user); SubscriberMock.Verify( s => s.PublishAsync( It.Is <RedisChannel>(channel => channel == RedisChannels.UserDisconnect), It.Is <RedisValue>(value => value == jsonUser), It.IsAny <CommandFlags>()), Times.Once); }
public async Task JoinLobby(LobbyConnectRequest lobbyConnectRequest) { var lobby = this.lobbyManagerService.Lobbies.FirstOrDefault(x => x.Name == lobbyConnectRequest.LobbyName); var type = lobby.Type; var conenctResponse = new LobbyConnectResponse(); var lobbyUser = new LobbyUser() { Id = this.Context.ConnectionId, Name = lobbyConnectRequest.UserName }; if (lobby.LobbyUsers.Count < 4) { if (lobby.LobbyUsers.Count == 0) { lobby.HostId = lobbyUser.Id; } lobby.LobbyUsers.Add(lobbyUser); conenctResponse.Succeded = true; conenctResponse.LobbyName = lobby.Name; await this.Clients.Caller.SendAsync(ChannelConstants.LobbyConnectionAnswer, conenctResponse); await this.Groups.AddToGroupAsync(this.Context.ConnectionId, lobby.Name); await this.UpdateLobbies(type); } else { conenctResponse.Succeded = false; conenctResponse.LobbyName = lobby.Name; await this.Clients.Caller.SendAsync(ChannelConstants.LobbyConnectionAnswer, conenctResponse); } }
public void ReceivePeerData(NetworkMessage msg, LobbyUser user) { user.PushInboundMessage(msg); CheckAlive(); }
public void PeerRemoved(LobbyUser user) { lock (RemovedUsers) RemovedUsers.Add(user); }
protected virtual void HandleUserMessage(LobbyUser user, NetworkMessage message) { }
protected virtual void HandleUserAdded(LobbyUser user) { }
public static void Remove(int UID, out LobbyUser val) { logUser.Remove(UID, out val); }
public static bool Add(int UID, int PID, byte key, byte[] GUID) { LobbyUser lUser = new LobbyUser(UID, PID, key, GUID); return(logUser.Add(UID, lUser)); }
protected override void HandleUserMessage(LobbyUser user, NetworkMessage message) { base.HandleUserMessage(user, message); }
protected override void HandleUserRemoved(LobbyUser user) { base.HandleUserRemoved(user); }
protected virtual void HandleUserRemoved(LobbyUser user) { }