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 void RemoveGame(Guid gameId)
{
if (!GamesById.ContainsKey(gameId))
{
Logger.LogWarning($"Got close for game {gameId} that we didn't know about");
return;
}
GamesById.Remove(gameId);
}
/// <summary>
/// Calculates the ELO score for all players and their results. By default we assume a score of 1500 for a new player.
/// </summary>
/// <param name="a_GameOrFamilyId">Three possible ways to use it: Either a Guid for a single game or a game family works.
/// If the ID is null or invalid the whole results database will be used.</param>
/// <returns>A dictionary with the Player as key and a ResultHelper object containing the calculated results.</returns>
public Dictionary <Player, Result.ResultHelper> CalculateEloResults(Guid a_GameOrFamilyId)
{
Dictionary <Player, Result.ResultHelper> v_EloResults = new Dictionary <Player, Result.ResultHelper>();
// Start with the standard ELO number for every player.
foreach (Player i_Player in Players)
{
v_EloResults.Add(i_Player, new Result.ResultHelper(i_Player.Id, c_EloStartValue, 0));
}
// We want to start with the oldest results. The UI shows newest results on the top so we need to reverse order here.
IEnumerable <Result> v_BeginningToEndResults = new ObservableCollection <Result>(Results.OrderBy(p => p.Date));
if (GameFamiliesById.ContainsKey(a_GameOrFamilyId))
{
// First: Get all games from the given game family.
var v_AllGamesFromFamily = Games.Where(p => p.IdGamefamilies.Contains(a_GameOrFamilyId));
if (v_AllGamesFromFamily.Count() > 0)
{
// Second: Get all results with games of the given game family.
v_BeginningToEndResults = v_BeginningToEndResults.Join(v_AllGamesFromFamily,
result => result.IdGame,
game => game.Id,
(result, game) => result);
}
else
{
v_BeginningToEndResults = new ObservableCollection <Result>();
}
}
else if (GamesById.ContainsKey(a_GameOrFamilyId))
{
v_BeginningToEndResults = v_BeginningToEndResults.Where(p => p.IdGame == a_GameOrFamilyId);
}
foreach (Result i_Result in v_BeginningToEndResults)
{
Dictionary <Guid, Result.ResultHelper> v_TempEloResults = new Dictionary <Guid, Result.ResultHelper>();
// We do not consider results of solo games.
if (i_Result.Scores.Count == 1)
{
continue;
}
foreach (Score i_Score in i_Result.Scores)
{
v_TempEloResults.Add(i_Score.IdPlayer, v_EloResults[PlayersById[i_Score.IdPlayer]]);
}
if (GamesById[i_Result.IdGame].Type == Game.GameType.Ranks)
{
i_Result.CalculateEloResultsForRanks(v_TempEloResults, i_Result.Date);
}
else
{
i_Result.CalculateEloResults(v_TempEloResults, i_Result.Date);
}
}
return(v_EloResults);
}