private void FillPlayedCards(CurrentGameDataViewModel model, List <CardPlayed> cardsPlayed, PlayerPosition playerPosition)
{
foreach (var cardPlayed in cardsPlayed)
{
var onScreenPosition = playerPosition.GetOnScreenPosition(cardPlayed.PlayerPosition);
Card card = CardsManager.GetCardFromString(cardPlayed.CardString);
switch (onScreenPosition)
{
case PlayerPosition.Up:
model.UpCard = card.ImgPath;
break;
case PlayerPosition.Left:
model.LeftCard = card.ImgPath;
break;
case PlayerPosition.Right:
model.RightCard = card.ImgPath;
break;
case PlayerPosition.Down:
model.DownCard = card.ImgPath;
break;
}
}
}
private PlayerPosition GetWiningCallPosition(Round round)
{
Call call = null;
var orderedCalls = round.Calls.OrderByDescending(c => c.Type);
var firstCall = orderedCalls.FirstOrDefault();
if (firstCall.Type == CallType.EightInARow || firstCall.Type == CallType.FourJacks || firstCall.Type == CallType.FourNines)
{
call = firstCall;
}
if (firstCall.Type == CallType.FourOfAKind)
{
call = orderedCalls
.ThenBy(c => Array.IndexOf(CustomSorting.FourOfAKindSortOrder, CardsManager.GetCardFromString(c.HighestCard).Value))
.FirstOrDefault();
}
if (firstCall.Type == CallType.SevenInARow || firstCall.Type == CallType.SixInARow || firstCall.Type == CallType.FiveInARow || firstCall.Type == CallType.FourInARow || firstCall.Type == CallType.ThreeInARow)
{
var maxValue = round.Calls.Select(c => c.Value).Max();
call = orderedCalls
.Where(c => c.Value == maxValue)
.OrderByDescending(c => CardsManager.GetCardFromString(c.HighestCard).Value)
.ThenBy(c => Array.IndexOf(CustomSorting.GetPositionSortingOrderForCalls(round.FirstPlayerToPlay), c.PlayerPosition))
.FirstOrDefault();
}
return(call.PlayerPosition);
}
public async Task <Result> MakeACall(List <string> cardStrings, int roundId, int userId, bool isCall)
{
var result = Result.Success();
int highestCallValue = 0;
PlayerPosition?winningCallPosition = null;
Round round = await _gameRepository.GetRoundById(roundId);
Player player = await _playerRepository.GetPlayerByUserIdAsync(userId);
if (isCall)
{
if (cardStrings.Count > 2)
{
List <Card> cards = cardStrings.Select(cs => CardsManager.GetCardFromString(cs)).ToList();
List <Call> foundCalls = new List <Call>();
List <Card> fourOfAKindRemained = new List <Card>();
List <Card> sequenceRemained = new List <Card>();
FindFourOfAKindCalls(cards, player.PlayerPosition.Value, ref foundCalls, ref fourOfAKindRemained);
FindSequenceCalls(cards, player.PlayerPosition.Value, ref foundCalls, ref sequenceRemained);
if (!DoListsHaveMatchingCard(fourOfAKindRemained, sequenceRemained))
{
round.Calls.AddRange(foundCalls);
highestCallValue = foundCalls.OrderByDescending(c => c.Value).FirstOrDefault().Value;
}
else
{
return(Result.Fail(new string[] { "Nevažeće zvanje" }));
}
}
else
{
return(Result.Fail(new string[] { "Nevažeće zvanje" }));
}
}
round.CurrentPlayerToPlay = round.CurrentPlayerToPlay.GetNextPosition();
if (round.CurrentPlayerToPlay == round.FirstPlayerToPlay)
{
round.RoundPhase = round.RoundPhase.GetNextPhase();
if (round.Calls.Count > 0)
{
winningCallPosition = GetWiningCallPosition(round);
await ResolveCalls(round, winningCallPosition.Value);
}
}
result.Values = GetResultObjForCall(round, highestCallValue, winningCallPosition);
if (await _gameRepository.SaveAsync())
{
return(result);
}
return(Result.Fail(new string[] { "Dogodila se greška" }));
}
private void ResolveTurn(Round round, Game game, bool isLastTurn)
{
var cardsPlayed = round.CardsPlayed.Where(cp => cp.RoundPhase == round.RoundPhase).ToList();
var sum = cardsPlayed.Sum(cp => cp.Value);
var cards = cardsPlayed.Select(cp => CardsManager.GetCardFromString(cp.CardString)).ToList();
var strongestCard = GetStrongestCardInTurn(cards, round.CurrentTrump.Value);
var winningPosition = round.CardsPlayed.Where(cp => strongestCard.ToString() == cp.CardString).FirstOrDefault().PlayerPosition;
var playerThatWonTurn = game.PlayerGames.Where(pg => pg.Player.PlayerPosition == winningPosition).Select(pg => pg.Player).FirstOrDefault();
SetPointValuesInTurn(round, playerThatWonTurn.Team.Value, sum, isLastTurn);
round.CurrentPlayerToPlay = winningPosition;
}
public async Task <List <List <string> > > GetListOfCardUrlsForCall(int roundId, int playerPosition, bool isPartner)
{
List <List <string> > urls = new List <List <string> >();
var position = isPartner ? ((PlayerPosition)playerPosition).GetTeammatePosition() : (PlayerPosition)playerPosition;
var round = await _gameRepository.GetRoundById(roundId);
List <Call> calls = round.Calls.Where(c => c.PlayerPosition == position).ToList();
foreach (var call in calls)
{
Card card = CardsManager.GetCardFromString(call.HighestCard);
urls.Add(FindCallCardUrlsFromHighestCard(card, call.Type));
}
return(urls);
}
public async Task <Result> PlayACard(string playedCardString, int roundId, int userId, PlayerPosition position, List <string> cardsInHandStrings, bool belaCalled)
{
Round round = await _gameRepository.GetRoundById(roundId);
Player player = await _playerRepository.GetPlayerByUserIdAsync(userId);
var cardsPlayed = round.CardsPlayed.Where(cp => cp.RoundPhase == round.RoundPhase)
.OrderBy(cp => cp.DateCreated)
.Select(cp => CardsManager.GetCardFromString(cp.CardString))
.ToList();
var cardsInHand = CardsManager.GetCardListFromHandString(string.Join(",", cardsInHandStrings));
var playedCard = CardsManager.GetCardFromString(playedCardString);
var validCards = ValidCardsHelper.GetValidCardsForPlay(cardsInHand, round.CurrentTrump.Value, cardsPlayed);
if (validCards.Contains(playedCard))
{
var result = Result.Success();
round.CardsPlayed.Add(new CardPlayed(round.RoundPhase, position, playedCard, round.CurrentTrump.Value));
cardsInHand.Remove(playedCard);
cardsInHand = cardsInHand.OrderCards();
player.Hand = string.Join(",", cardsInHand);
Game game = null;
var roundAlert = "";
var isLastTurn = false;
var isGameOver = false;
if (belaCalled)
{
if (player.Team.Value == Team.FirstTeam)
{
round.FirstTeamCalls += 20;
round.FirstTeamRoundTotal += 20;
}
if (player.Team.Value == Team.SecondTeam)
{
round.SecondTeamCalls += 20;
round.SecondTeamRoundTotal += 20;
}
}
if (round.CardsPlayed.Where(cp => cp.RoundPhase == round.RoundPhase).ToList().Count == 4)
{
isLastTurn = round.RoundPhase == RoundPhase.EighthCard;
game = await _gameRepository.GetGameWithPlayersById(round.GameId);
ResolveTurn(round, game, isLastTurn);
if (isLastTurn)
{
round.CurrentPlayerToPlay = round.FirstPlayerToPlay.GetNextPosition();
roundAlert = await ResolveRound(round, game);
if (IsGameOver(game))
{
isGameOver = true;
await SetGameOverDataAsync(game);
}
else
{
AddNextRound(game, round);
var players = game.PlayerGames.Select(pg => pg.Player).ToList();
FillPlayersHands(players);
}
}
else
{
round.RoundPhase = round.RoundPhase.GetNextPhase();
}
}
else
{
round.CurrentPlayerToPlay = round.CurrentPlayerToPlay.GetNextPosition();
}
if (await _gameRepository.SaveAsync())
{
var currentRoundId = round.Id;
var currentPhase = round.RoundPhase;
if (isLastTurn)
{
var newRound = game.Rounds.OrderByDescending(r => r.Id).FirstOrDefault();
currentRoundId = newRound.Id;
currentPhase = newRound.RoundPhase;
}
result.Values = GetResultObjForCardPlayed(round, position, playedCard, roundAlert, currentRoundId, currentPhase, isLastTurn, isGameOver, belaCalled);
return(result);
}
return(Result.Fail(new string[] { "Dogodila se greška" }));
}
return(Result.Fail(new string[] { "Nevažeća karta" }));
}
