public async Task <GameResponse> StartGameAsync(string connectionId)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got start game message for unknown connection id '{connectionId}'");
return(GameResponse.Failure("Connection not found"));
}
var user = UsersByConnectionId[connectionId];
var game = FindGameForUser(user.Name);
if (game == null)
{
Logger.LogError($"No games found to start for {user.Name}");
return(GameResponse.Failure("Game not found"));
}
if (game.Owner != user.Name)
{
return(GameResponse.Failure("You are not the game owner and cannot start the game."));
}
await Task.Delay(1);
return(GameResponse.Succeeded(game));
}
private async Task <LobbyGame> DisconnectedUserInternalAsync(string connectionId)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got user disconnect for unknown connection Id '{connectionId}'");
return(null);
}
var user = UsersByConnectionId[connectionId];
await subscriber.PublishAsync(RedisChannels.UserDisconnect, JsonConvert.SerializeObject(user));
var game = FindGameForUser(user.Name);
if (game == null || game.Started)
{
return(null);
}
game.PlayerDisconnected(user.Name);
if (!game.IsEmpty())
{
return(game);
}
GamesById.Remove(game.Id);
await subscriber.PublishAsync(RedisChannels.RemoveGame, game.Id.ToString());
return(game);
}
public async Task <GameResponse> JoinGameAsync(string connectionId, Guid gameId, string password)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got join game message for unknown connection id '{connectionId}'");
return(GameResponse.Failure("Connection not found"));
}
var user = UsersByConnectionId[connectionId];
if (!GamesById.ContainsKey(gameId))
{
Logger.LogError($"Got join game message for unknown game id '{gameId}'");
return(GameResponse.Failure("Game not found"));
}
var game = GamesById[gameId];
var joinResponse = game.Join(user, password);
if (!joinResponse.Success)
{
return(joinResponse);
}
await subscriber.PublishAsync(RedisChannels.UpdateGame, JsonConvert.SerializeObject(game));
return(joinResponse);
}
public async Task <LobbyGame> LeaveGameAsync(string connectionId)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got leave game message for unknown connection id '{connectionId}'");
return(null);
}
var user = UsersByConnectionId[connectionId];
var game = FindGameForUser(user.Name);
if (game == null || game.Started)
{
return(null);
}
game.PlayerLeave(user.Name);
if (!game.IsEmpty())
{
await subscriber.PublishAsync(RedisChannels.UpdateGame, JsonConvert.SerializeObject(game));
return(game);
}
GamesById.Remove(game.Id);
await subscriber.PublishAsync(RedisChannels.RemoveGame, game.Id.ToString());
return(game);
}
public GameResponse SelectDeck(string connectionId, PlayerDeck deck)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got select deck message for unknown connection id '{connectionId}'");
return(GameResponse.Failure("An error occurred selecting your deck. Please try again later."));
}
var user = UsersByConnectionId[connectionId];
var game = FindGameForUser(user.Name);
if (game == null)
{
Logger.LogError($"Got select deck message for user '{user.Name}' with no game");
return(GameResponse.Failure("Could not select your deck because your game was not found. Please restart your game."));
}
if (!game.GetPlayers().ContainsKey(user.Name))
{
Logger.LogError($"Got select deck message for user '{user.Name}' game '{game.Id}' which they are not in.");
return(GameResponse.Failure("An error occurred selecting your deck. Please try again later."));
}
var player = game.GetPlayers()[user.Name];
var customData = JsonConvert.DeserializeObject <PlayerCustomData>(player.CustomData) ?? new PlayerCustomData();
customData.Deck = deck;
player.CustomData = JsonConvert.SerializeObject(customData);
return(GameResponse.Succeeded(game));
}
private void OnNewUserMessage(RedisChannel channel, RedisValue value)
{
var lobbyUser = JsonConvert.DeserializeObject <LobbyUser>(value);
if (lobbyUser.Node == options.NodeName)
{
return;
}
UsersByConnectionId.Add(lobbyUser.ConnectionId, lobbyUser);
}
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));
}
private async Task <GameResponse> StartNewGameInternalAsync(string connectionId, StartNewGameRequest request)
{
if (!UsersByConnectionId.ContainsKey(connectionId))
{
Logger.LogError($"Got new game message for unknown connection id '{connectionId}'");
return(GameResponse.Failure("Connection not found"));
}
var user = UsersByConnectionId[connectionId];
var existingGame = FindGameForUser(user.Name);
if (existingGame != null)
{
Logger.LogError($"Got new game message for user already in game '{user.Name}' '{existingGame.Name}'");
return(GameResponse.Failure("You are already in a game so cannot start a new one"));
}
if (request.QuickJoin)
{
var pendingGame = GamesById.Values.OrderBy(g => g.Started).FirstOrDefault(game => game.CanQuickJoin(game.GameType));
if (pendingGame != null)
{
}
return(GameResponse.Succeeded(pendingGame));
}
var newGame = new LobbyGame(user.Name, request);
newGame.NewGame(user);
GamesById.Add(newGame.Id, newGame);
await subscriber.PublishAsync(RedisChannels.NewGame, JsonConvert.SerializeObject(newGame));
return(GameResponse.Succeeded(newGame));
}
private void OnUserDisconnectMessage(RedisChannel channel, RedisValue user)
{
UsersByConnectionId.Remove(user);
}
