public async Task <Game> CreateGameAsync(OneToOneBattle battle, long playerId, CancellationToken cancellationToken = default)
{
var game = new Game
{
CurrentTurnPlayerId = playerId,
GameState = GameStateIds.SelectCategory,
Battle = battle
};
var randomCategoryIds = new HashSet <long>();
while (game.GameCategories.Count < 3)
{
var randomCategory = await _dataContext.Categories.Where(q => q.IsArchived == false).OrderBy(q => Guid.NewGuid()).FirstOrDefaultAsync(cancellationToken);
if (randomCategory != null && randomCategoryIds.Add(randomCategory.Id))
{
game.GameCategories.Add(new GameCategory
{
CategoryId = randomCategory.Id
});
}
}
battle.Games.Add(game);
_dataContext.Games.Add(game);
return(game);
}
public async Task ProcessBattleAchievementsAsync(OneToOneBattle battle, AccountStatsSummary player1Stats, AccountStatsSummary player2Stats, CancellationToken cancellationToken)
{
var achievementTypes = await _context.AchievementTypes.AsNoTracking().Where(q => q.IsArchived == false).ToListAsync(cancellationToken);
var achievements = await _context.Achievements.Where(q => q.IsArchived == false && (q.AccountId == battle.Player1Id || q.AccountId == battle.Player2Id)).ToListAsync(cancellationToken);
var player1Achievements = achievements.Where(q => q.AccountId == battle.Player1Id)
.ToDictionary(q => q.AchievementTypeId);
var player2Achievements = achievements.Where(q => q.AccountId == battle.Player1Id)
.ToDictionary(q => q.AchievementTypeId);
// Winner
foreach (var a in achievementTypes)
{
if (a.WinnedBattlesCount != null)
{
ProcessWinnerAchievement(battle.Player1Id, player1Stats, player1Achievements, a);
ProcessWinnerAchievement(battle.Player2Id.Value, player2Stats, player2Achievements, a);
}
else if (a.AceWinCount != null)
{
ProcessAceWinAchievement(battle.Player1Id, player1Stats, player1Achievements, a);
ProcessAceWinAchievement(battle.Player2Id.Value, player2Stats, player2Achievements, a);
}
else if (a.NumberOfTotalBattlesPlayed != null)
{
ProcessTotalBattlesAchievement(battle.Player1Id, player1Stats, player1Achievements, a);
ProcessTotalBattlesAchievement(battle.Player2Id.Value, player2Stats, player2Achievements, a);
}
}
await _context.SaveChangesAsync(cancellationToken);
}
public async ValueTask <OneToOneBattleViewModel> MapAsync(OneToOneBattle battle, CancellationToken cancellationToken)
{
var vm = Mapper.Map <OneToOneBattleViewModel>(battle);
List <PlayerCorrectAnswer> playerCorrectAnswers = new List <PlayerCorrectAnswer>();
foreach (var answer in battle.Games)
{
playerCorrectAnswers.Add(new PlayerCorrectAnswer
{
GameId = answer.Id,
Player1CorrectAnswer = answer.GameQuestions.Sum(q => q.Player1SelectedAnswer == q.Question.CorrectAnswerNumber ? 1 : 0),
Player2CorrectAnswer = answer.GameQuestions.Sum(q => q.Player2SelectedAnswer == q.Question.CorrectAnswerNumber ? 1 : 0)
});
}
vm.PlayerCorrectAnswers = playerCorrectAnswers;
var games = battle.Games.OrderBy(x => x.Id);
var lastgame = games.LastOrDefault(x => x.BattleId == vm.Id);
if (battle.Games != null)
{
vm.Game = Mapper.Map <List <GameViewModel> >(battle.Games);
}
if (lastgame != null)
{
vm.CurrentTurnPlayerId = lastgame.CurrentTurnPlayerId;
vm.ShouldAnswer =
((vm.CurrentTurnPlayerId == vm.Player1Id &&
lastgame.GameState == GameStateIds.Player1AnswerQuestions) ||
(vm.CurrentTurnPlayerId == vm.Player2Id &&
lastgame.GameState == GameStateIds.Player2AnswerQuestions));
vm.ShouldSelectCategory =
((vm.CurrentTurnPlayerId == vm.Player1Id && lastgame.GameState == GameStateIds.SelectCategory)) ||
((vm.CurrentTurnPlayerId == vm.Player2Id && lastgame.GameState == GameStateIds.SelectCategory));
}
vm.Player1MiniProfile = await _playerMiniProfileCache.GetMiniProfileAsync(battle.Player1Id, cancellationToken);
if (battle.Player2Id.HasValue)
{
vm.Player2MiniProfile = await _playerMiniProfileCache.GetMiniProfileAsync(battle.Player2Id.Value, cancellationToken);
}
return(vm);
}
private async Task <OneToOneBattle> StartNewRandomBattleAsync(Account player1, Account player2 = default,
CancellationToken cancellationToken = default)
{
var battle = new OneToOneBattle
{
BattleType = BattleType.OneOnOne,
Player1Id = player1.Id,
Player2Id = player2?.Id,
Round = 1,
StartDateTime = player2 != null ? DateTime.UtcNow : (DateTime?)null,
BattleStateId = player2 != null ? BattleStateIds.SelectCategory : BattleStateIds.WaitingForOpponent,
CreationDateTime = DateTime.UtcNow,
};
_dataContext.Battles.Add(battle);
if (player2 != null)
{
await AddStartGameToBattle(player1.Id, cancellationToken, battle);
}
return(battle);
}
private async Task AddStartGameToBattle(long playerId, CancellationToken cancellationToken, OneToOneBattle battle)
{
var startingGame = await CreateGameAsync(battle, playerId, cancellationToken);
battle.Games.Add(startingGame);
startingGame.Battle = battle;
await _dataContext.SaveChangesAsync(cancellationToken);
//battle.LastGame = startingGame;
battle.LastGameId = startingGame.Id;
}
