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)
{
}
