public static void CheckPossibleSelfKong(Round round, RoundPlayer player) { var unopenTiles = round.RoundTiles.Where(t => string.IsNullOrEmpty(t.Owner)); if (unopenTiles.Count() == 0) { return; } var playerTiles = round.RoundTiles.Where(rt => rt.Owner == player.GamePlayer.Player.UserName && rt.TileSetGroup != TileSetGroup.Kong && rt.TileSetGroup != TileSetGroup.Chow); int possibleKongCount = playerTiles .GroupBy(t => new { t.Tile.TileType, t.Tile.TileValue }) .Where(grp => grp.Count() == 4) .Count();; if (possibleKongCount > 0) { for (int i = 0; i < possibleKongCount; i++) { player.RoundPlayerActions.Add(new RoundPlayerAction { ActionType = ActionType.SelfKong }); } } }
private void UpdateRounds(List <RoundPlayer> roundPlayers) { RoundPlayer dealer = roundPlayers .Where(roundPlayer => roundPlayer.Player.Type == PlayerType.Dealer) .First(); roundPlayers.Remove(dealer); foreach (var roundPlayer in roundPlayers) { int score = CalculateCardScore(roundPlayer.Cards.Select(roundPlayerCard => GetCardById(roundPlayerCard.CardId))); if (score > Constants.BlackJackValue) { roundPlayer.State = RoundPlayerState.Lose; } } int dealerScore = CalculateCardScore(dealer.Cards.Select(roundPlayerCard => GetCardById(roundPlayerCard.CardId))); if (dealerScore > Constants.BlackJackValue) { SetWinners(roundPlayers); } if (dealerScore <= Constants.BlackJackValue) { CheckStates(roundPlayers, dealerScore); } _roundPlayerRepository.Update(roundPlayers); }
public void Step() { Game game = _gameRepository.GetContinueableGame(_userId); if (game == null) { throw new InvalidOperationException("Game is not found"); } RoundPlayer user = _roundPlayerRepository.GetLastRoundPlayerInfo(game.Id, _userId); List <Card> roundCards = _cardRepository.GetLastRoundCards(game.Id).ToList(); if (user.State != RoundPlayerState.None) { throw new InvalidOperationException("Player can\'t to step when RoundState != None"); } List <long> shuffledCards = GetShuffledCards(roundCards); var roundPlayerCard = new RoundPlayerCard { RoundPlayerId = user.Id, CardId = shuffledCards[0] }; _roundPlayerCardRepository.Add(roundPlayerCard); if (!IsStepPossible(game)) { Skip(); } }
private void CreateRound(Game game, int neededBotCount) { IEnumerable <Player> bots = _playerRepository.GetBots(neededBotCount); RoundPlayer user = new RoundPlayer { GameId = game.Id, PlayerId = _userId }; var roundPlayers = new List <RoundPlayer> { user }; foreach (var bot in bots) { RoundPlayer botRound = new RoundPlayer { GameId = game.Id, PlayerId = bot.Id }; roundPlayers.Add(botRound); } RoundPlayer dealer = new RoundPlayer { GameId = game.Id, PlayerId = Constants.DealerId }; roundPlayers.Add(dealer); _roundPlayerRepository.Add(roundPlayers); CreateCards(roundPlayers); if (!IsStepPossible(game)) { Skip(); } }
public ICollection <RoundTileDto> Resolve(RoundPlayer source, RoundPlayerDto destination, ICollection <RoundTileDto> destMember, ResolutionContext context) { var roundId = source.RoundId; var RoundPlayerTiles = _context.RoundTiles.Where(rt => rt.RoundId == roundId && rt.Owner == source.GamePlayer.Player.UserName); return(_mapper.Map <ICollection <RoundTile>, ICollection <RoundTileDto> >(RoundPlayerTiles.ToList())); }
public ICollection <RoundPlayerActionDto> Resolve(RoundPlayer source, RoundPlayerDto destination, ICollection <RoundPlayerActionDto> destMember, ResolutionContext context) { var roundId = source.RoundId; var activeActions = source.RoundPlayerActions.Where(a => a.ActionStatus == ActionStatus.Active); var dtoresult = _mapper.Map <ICollection <RoundPlayerAction>, ICollection <RoundPlayerActionDto> >(activeActions.ToList()); return(dtoresult); }
public int Create(Models.RoundPlayer item) { RoundPlayer roundPlayer = Mapper.ToEntity(item); _context.RoundPlayers.Add(roundPlayer); _context.SaveChanges(); return(roundPlayer.Id); }
private void OnPlayerChat(RoundPlayer roundplayer, string message) { PlayerBase p = roundplayer.PlayerBase; IPlayer pp = (IPlayer)roundplayer; //pp.Hurt(50f); Puts(p.Health.ToString() + " " + roundplayer.WeaponHolder.CanJump.ToString()); Puts(message); }
public static bool DetermineIfUserCanWin(Round round, RoundPlayer player, IPointsCalculator pointCalculator) { HandWorth handWorth = pointCalculator.Calculate(round, player.GamePlayer.Player.UserName); if (handWorth == null) { return(false); } return(handWorth.Points >= round.Game.MinPoint); }
public void Delete(int id) { RoundPlayer item = _context.RoundPlayers.Find(id); if (item != null) { _context.RoundPlayers.Remove(item); _context.SaveChanges(); } }
public static DAL.Entities.RoundPlayer ToEntity(RoundPlayer roundPlayer) { DAL.Entities.RoundPlayer roundPlayerOut = new DAL.Entities.RoundPlayer { Id = roundPlayer.Id, PlayerId = roundPlayer.PlayerId, RoundId = roundPlayer.RoundId, IsWin = roundPlayer.IsWin }; return(roundPlayerOut); }
public static void CheckSelfAction(Round round, RoundPlayer roundPlayer, IPointsCalculator pointsCalculator) { if (DetermineIfUserCanWin(round, roundPlayer, pointsCalculator)) { roundPlayer.RoundPlayerActions.Add(new RoundPlayerAction { ActionType = ActionType.SelfWin }); } CheckPossibleSelfKong(round, roundPlayer); }
public static RoundPlayer ToModel(DAL.Entities.RoundPlayer roundPlayer) { RoundPlayer roundPlayerOut = new RoundPlayer { Id = roundPlayer.Id, PlayerId = roundPlayer.PlayerId, RoundId = roundPlayer.RoundId, IsWin = roundPlayer.IsWin }; return(roundPlayerOut); }
public static RoundPlayerServiceViewModel Map(RoundPlayer entity) { var viewModel = new RoundPlayerServiceViewModel() { Id = entity.Id.ToString(), RoundId = entity.RoundId.ToString(), PlayerId = entity.PlayerId.ToString(), Bet = entity.Bet, Cards = entity.Cards }; return(viewModel); }
static bool Prefix(string entryText, RoundPlayer player, out bool __result) { string text; bool flag2; Exception ex; string input = null; foreach (AdminMessage processor in adminMessageDelegate.GetInvocationList()) { input = processor(entryText); if (input != null) { ServerComponentReferenceManager.ServerInstance.console .ExecuteInput(input, player.NetworkPlayerID, out text, out flag2, out ex, true); break; } } __result = input != null; return(input == null); }
public void StartFirstRound(int gameId, IEnumerable <int> playersId) { int number = _roundRepository.GetCountRoundsByGame(gameId); Round round = new Round { GameId = gameId, NumberRound = number + 1, IsCompleted = false }; round.Id = _roundRepository.Create(round); foreach (int id in playersId) { RoundPlayer roundPlayer = new RoundPlayer { RoundId = round.Id, PlayerId = id }; _roundPlayerRepository.Create(roundPlayer); } }
public static RoundPlayer Map(RoundPlayerServiceViewModel viewModel) { if (Guid.TryParse(viewModel.Id, out Guid id) && Guid.TryParse(viewModel.RoundId, out Guid roundId) && Guid.TryParse(viewModel.PlayerId, out Guid playerId)) { var entity = new RoundPlayer() { Id = id, RoundId = roundId, PlayerId = playerId, Bet = viewModel.Bet, Cards = viewModel.Cards }; return(entity); } return(new RoundPlayer { Id = Guid.Empty, PlayerId = Guid.Empty, RoundId = Guid.Empty }); }
private List <RoundPlayerCard> DoPlayBot(RoundPlayer roundPlayer, List <long> shuffledCards) { if (roundPlayer.Player.Type == PlayerType.User) { return(Enumerable.Empty <RoundPlayerCard>().ToList()); } var roundCards = new List <RoundPlayerCard>(); int gotCardsCount = 0; int score = CalculateCardScore(roundPlayer.Cards.Select(roundPlayerCard => roundPlayerCard.Card)); while (score < Constants.DealerStopValue) { Card card = GetCardById(shuffledCards[gotCardsCount]); var roundCard = new RoundPlayerCard { CardId = card.Id, RoundPlayerId = roundPlayer.Id }; gotCardsCount++; roundCards.Add(roundCard); roundPlayer.Cards.Add(roundCard); score = CalculateCardScore(roundPlayer.Cards.Select(roundPlayerCard => GetCardById(roundPlayerCard.CardId))); } return(roundCards); }
private IEnumerable <RoundPlayer> GetNewUserRounds(IEnumerable <RoundPlayer> userRounds, bool sameRound, WindDirection windOfDealer) { List <RoundPlayer> ret = new List <RoundPlayer>(); foreach (var lur in userRounds) { var userWind = sameRound ? lur.Wind : NextWindAntiClockwise(lur.Wind); var ur = new RoundPlayer { GamePlayerId = lur.GamePlayerId, GamePlayer = lur.GamePlayer, IsInitialDealer = lur.IsInitialDealer, IsDealer = lur.Wind == windOfDealer, IsMyTurn = lur.Wind == windOfDealer, MustThrow = lur.Wind == windOfDealer, Points = lur.Points, Wind = userWind }; ret.Add(ur); } return(ret); }
public async Task <IEnumerable <RoundDto> > Handle(Command request, CancellationToken cancellationToken) { var game = await _context.Games.FirstOrDefaultAsync(x => x.Code == request.GameCode.ToUpper()); if (game == null) { throw new RestException(HttpStatusCode.NotFound, new { Game = "Could not find game" }); } var round = game.Rounds.FirstOrDefault(r => r.Id == request.RoundId); if (round == null) { throw new RestException(HttpStatusCode.NotFound, new { Round = "Could not find round" }); } RoundPlayer roundPlayerWinner = round.RoundPlayers.FirstOrDefault(u => u.GamePlayer.Player.UserName == request.UserName); if (roundPlayerWinner == null) { throw new RestException(HttpStatusCode.NotFound, new { Player = "Could not find player" }); } //check for valid win: HandWorth handWorth = _pointCalculator.Calculate(round, request.UserName); if (handWorth == null) { throw new RestException(HttpStatusCode.BadRequest, new { Win = "Invalid combination hand" }); } if (handWorth.Points >= game.MinPoint) { var winAction = roundPlayerWinner.RoundPlayerActions.FirstOrDefault(a => a.ActionType == ActionType.Win); if (winAction != null) { winAction.ActionStatus = ActionStatus.Activated; } bool isSelfPick = false; //set the game as over if all win action is settled var playerWithUnsettledWin = round.RoundPlayers.Where(p => p.RoundPlayerActions.Any(pa => pa.ActionType == ActionType.Win && pa.ActionStatus == ActionStatus.Active)); if (playerWithUnsettledWin.Count() == 0) { round.IsOver = true; round.IsEnding = false; } //create the result and record who win and who lost RoundResult winnerResult = new RoundResult { Player = roundPlayerWinner.GamePlayer.Player, PlayResult = PlayResult.Win, }; if (round.RoundResults == null) { round.RoundResults = new List <RoundResult>(); } //record hand type and extra points foreach (var h in handWorth.HandTypes) { var point = _pointCalculator.HandTypeLookup[h]; winnerResult.RoundResultHands.Add(new RoundResultHand { HandType = h, Point = point, Name = h.ToString() }); } foreach (var e in handWorth.ExtraPoints) { if (e == ExtraPoint.SelfPick) { isSelfPick = true; } var point = _pointCalculator.ExtraPointLookup[e]; winnerResult.RoundResultExtraPoints.Add(new RoundResultExtraPoint { ExtraPoint = e, Point = point, Name = e.ToString() }); } //now that we have the winner hand type and extra point recorded, let's calculate the points //if the handworth exceed game max point, cap the point to game's max point var cappedPoint = handWorth.Points > game.MaxPoint ? game.MaxPoint : handWorth.Points; var losingPoint = cappedPoint * -1; if (isSelfPick) { //check if "bao" //if there is AllOneSuit or SmallDragon or BigDragon or smallFourWind or bigFourWind //then the one that "bao" will be the only one that pays to the winner bool isLoserBao = false; string baoPlayerUserName = string.Empty; //check for allonesuit var winnerTiles = round.RoundTiles.Where(t => t.Owner == roundPlayerWinner.GamePlayer.Player.UserName); if (handWorth.HandTypes.Contains(HandType.AllOneSuit) || handWorth.HandTypes.Contains(HandType.SmallFourWind) || handWorth.HandTypes.Contains(HandType.BigFourWind)) { //check if the 4th tilesetgroupindex has thrownby value var fourthGroupTileIndex = winnerTiles.FirstOrDefault(t => t.TileSetGroupIndex == 4 && !string.IsNullOrEmpty(t.ThrownBy)); if (fourthGroupTileIndex != null) { isLoserBao = true; baoPlayerUserName = fourthGroupTileIndex.ThrownBy; } } //check for dragon if (handWorth.HandTypes.Contains(HandType.SmallDragon) || handWorth.HandTypes.Contains(HandType.BigDragon)) { //find the index of first pong dragon var pongOrKongDragons = winnerTiles.Where(t => (t.TileSetGroup == TileSetGroup.Pong || t.TileSetGroup == TileSetGroup.Kong) && t.Tile.TileType == TileType.Dragon && !string.IsNullOrEmpty(t.ThrownBy)); //if there is 3rd set of dragon pong/kong, then its not a bao //weird rule ever //then find the index of second pong dragon and check thrown by if (pongOrKongDragons.Count() == 2) { isLoserBao = true; baoPlayerUserName = pongOrKongDragons.OrderBy(t => t.TileSetGroupIndex).Last().ThrownBy; } } if (isLoserBao) { //the loser that bao will pay the winning point times three var winningPoint = cappedPoint * 3; roundPlayerWinner.Points += winningPoint; winnerResult.Points = winningPoint; RoundPlayer roundPlayerloser = round.RoundPlayers.FirstOrDefault(p => p.GamePlayer.Player.UserName == baoPlayerUserName); roundPlayerloser.Points -= winningPoint; round.RoundResults.Add(new RoundResult { PlayResult = PlayResult.LostWithPenalty, Player = roundPlayerloser.GamePlayer.Player, Points = losingPoint * 3 }); //record users that are tied var tiedPlayers = round.RoundPlayers.Where(p => p.GamePlayer.Player.UserName != baoPlayerUserName && p.GamePlayer.Player.UserName != roundPlayerWinner.GamePlayer.Player.UserName); tiedPlayers.ForEach(tp => { round.RoundResults.Add(new RoundResult { PlayResult = PlayResult.Tie, Player = tp.GamePlayer.Player, Points = 0 }); }); } else { //if its self pick, and no bao, then all 3 other players needs to record the loss var losers = round.RoundPlayers.Where(u => u.GamePlayer.Player.UserName != request.UserName); //points will be times 3 var winningPoint = cappedPoint * 3; roundPlayerWinner.Points += winningPoint; winnerResult.Points = winningPoint; losers.ForEach(l => { l.Points -= cappedPoint; round.RoundResults.Add(new RoundResult { PlayResult = PlayResult.Lost, Player = l.GamePlayer.Player, Points = losingPoint }); }); } } else { //otherwise there is only one loser that throw the tile to board roundPlayerWinner.Points += cappedPoint; winnerResult.Points = cappedPoint; var boardTile = round.RoundTiles.First(t => t.Owner == DefaultValue.board && t.Status == TileStatus.BoardActive); var loser = round.RoundPlayers.First(u => u.GamePlayer.Player.UserName == boardTile.ThrownBy); loser.Points -= cappedPoint; round.RoundResults.Add(new RoundResult { PlayResult = PlayResult.Lost, Player = loser.GamePlayer.Player, Points = losingPoint }); //check for multiple winners. If player has a valid win and already recorded as tie var tieResultCouldWin = round.RoundResults.FirstOrDefault(rr => rr.PlayResult == PlayResult.Tie && rr.Player.UserName == roundPlayerWinner.GamePlayer.Player.UserName); if (tieResultCouldWin != null) { //remove record that the player tie round.RoundResults.Remove(tieResultCouldWin); } else { //record users that are tied var tiedPlayers = round.RoundPlayers.Where(p => p.GamePlayer.Player.UserName != loser.GamePlayer.Player.UserName && p.GamePlayer.Player.UserName != roundPlayerWinner.GamePlayer.Player.UserName); tiedPlayers.ForEach(tp => { round.RoundResults.Add(new RoundResult { PlayResult = PlayResult.Tie, Player = tp.GamePlayer.Player, Points = 0 }); }); } } round.RoundResults.Add(winnerResult); //tally the point in gameplayer round.RoundPlayers.ForEach(rp => { rp.GamePlayer.Points = rp.Points; }); var success = await _context.SaveChangesAsync() > 0; if (success) { List <RoundDto> results = new List <RoundDto>(); foreach (var p in round.RoundPlayers) { results.Add(_mapper.Map <Round, RoundDto>(round, opt => opt.Items["MainRoundPlayer"] = p)); } return(results); } } else { throw new RestException(HttpStatusCode.BadRequest, new { Win = "Not enough point to win with this hand" }); } throw new Exception("Problem calling win"); }
public async Task <IEnumerable <RoundDto> > Handle(Command request, CancellationToken cancellationToken) { var game = await _context.Games.FirstOrDefaultAsync(x => x.Code == request.GameCode.ToUpper()); if (game == null) { throw new RestException(HttpStatusCode.BadRequest, new { Game = "Game does not exist" }); } Round lastRound = game.Rounds.OrderByDescending(r => r.DateCreated).FirstOrDefault(); if (lastRound != null && !lastRound.IsOver) { throw new RestException(HttpStatusCode.BadRequest, new { Round = "Last round is not over" }); } var newRound = new Round { GameId = game.Id, DateCreated = DateTime.Now, RoundTiles = RoundTileHelper.CreateTiles(_context).Shuffle(), RoundPlayers = new List <RoundPlayer>(), RoundResults = new List <RoundResult>() }; List <RoundPlayer> roundPlayers = new List <RoundPlayer>(); if (lastRound == null) { game.Status = GameStatus.Playing; Player firstDealer = game.GamePlayers.First(u => u.InitialSeatWind == WindDirection.East).Player; newRound.Wind = WindDirection.East; newRound.RoundCounter = 1; foreach (var gp in game.GamePlayers) { var rp = new RoundPlayer { GamePlayerId = gp.Id, GamePlayer = gp, Round = newRound, Wind = gp.InitialSeatWind.Value, Points = gp.Points }; if (gp.PlayerId == firstDealer.Id) { rp.IsInitialDealer = true; rp.IsDealer = true; rp.IsMyTurn = true; rp.MustThrow = true; } roundPlayers.Add(rp); } } else { newRound.RoundCounter = lastRound.RoundCounter + 1; var lastRoundDealer = lastRound.RoundPlayers.First(u => u.IsDealer); //if this is not the first round //last round check //1.) if the winner of last round == dealer then no wind change //2.) if last round "IsTied" set to true then no wind change if (lastRound.IsTied) { newRound.Wind = lastRound.Wind; roundPlayers.AddRange(GetNewUserRounds(lastRound.RoundPlayers, sameRound: true, lastRoundDealer.Wind)); } else { //if last game is not tied, then there gotta be a winner here //could be more than one winners here var lastRoundWinners = lastRound.RoundResults.Where(x => x.PlayResult == PlayResult.Win); var dealerWonLastRound = lastRoundWinners.Any(x => x.PlayerId == lastRoundDealer.GamePlayer.Player.Id); if (dealerWonLastRound) { newRound.Wind = lastRound.Wind; roundPlayers.AddRange(GetNewUserRounds(lastRound.RoundPlayers, sameRound: true, lastRoundDealer.Wind)); } else { //determine nextdealer var windOfNextDealer = NextWindClockWise(lastRoundDealer.Wind); roundPlayers.AddRange(GetNewUserRounds(lastRound.RoundPlayers, sameRound: false, windOfNextDealer)); var roundWindChanged = roundPlayers.Any(p => p.IsDealer == true && p.IsInitialDealer == true); newRound.Wind = roundWindChanged ? NextWindClockWise(lastRound.Wind) : lastRound.Wind; } } } foreach (var ur in roundPlayers) { newRound.RoundPlayers.Add(ur); } var theDealer = roundPlayers.First(u => u.IsDealer); var dealerId = theDealer.GamePlayerId; //for debugging //RoundTileHelper.SetupForWinPongChowPriority(newRound.RoundTiles); //tiles assignment and sorting foreach (var gamePlayer in game.GamePlayers) { if (gamePlayer.Id == dealerId) { RoundTileHelper.AssignTilesToUser(14, gamePlayer.Player.UserName, newRound.RoundTiles); //set one tile status to be justpicked newRound.RoundTiles.First(rt => rt.Owner == gamePlayer.Player.UserName && rt.Tile.TileType != TileType.Flower).Status = TileStatus.UserJustPicked; var playerTiles = newRound.RoundTiles.Where(rt => rt.Owner == gamePlayer.Player.UserName && (rt.Status == TileStatus.UserActive || rt.Status == TileStatus.UserJustPicked)).ToList(); RoundTileHelper.AssignAliveTileCounter(playerTiles); } else { RoundTileHelper.AssignTilesToUser(13, gamePlayer.Player.UserName, newRound.RoundTiles); var playerTiles = newRound.RoundTiles.Where(rt => rt.Owner == gamePlayer.Player.UserName && rt.Status == TileStatus.UserActive).ToList(); RoundTileHelper.AssignAliveTileCounter(playerTiles); } } _context.Rounds.Add(newRound); var success = await _context.SaveChangesAsync() > 0; List <RoundDto> results = new List <RoundDto>(); foreach (var p in newRound.RoundPlayers) { results.Add(_mapper.Map <Round, RoundDto>(newRound, opt => opt.Items["MainRoundPlayer"] = p)); } if (success) { return(results); } throw new Exception("Problem creating a new round"); }
internal void PlayerDisconnected(RoundPlayer player) => connectedPlayers.Remove(player.NetworkPlayerID.ToString());
internal void PlayerConnected(RoundPlayer player) { allPlayers[player.NetworkPlayerID.ToString()] = new HoldfastPlayer(player); connectedPlayers[player.NetworkPlayerID.ToString()] = new HoldfastPlayer(player); }
internal HoldfastPlayer(RoundPlayer player) { this.player = player; }
private void OnPlayerDisconnected(RoundPlayer roundPlayer) => Puts($"{roundPlayer.PlayerBase.name} Disconnected");
private bool AssignPlayerActions(Round round, RoundPlayer throwerPlayer) { //TODO: Support multiple winner bool foundActionForUser = false; var roundTiles = round.RoundTiles; //there will be action except for the player that throw the tile var players = round.RoundPlayers.Where(rp => rp.GamePlayer.Player.UserName != throwerPlayer.GamePlayer.Player.UserName); var boardActiveTile = roundTiles.FirstOrDefault(rt => rt.Status == TileStatus.BoardActive); if (boardActiveTile == null) { throw new RestException(HttpStatusCode.NotFound, new { Round = "Could not find active board tile" }); } var nextPlayer = RoundHelper.GetNextPlayer(round.RoundPlayers, throwerPlayer.Wind); //there could be more than one possible action given user's turn and the tile's thrown foreach (var player in players) { var userTiles = roundTiles.Where(rt => rt.Owner == player.GamePlayer.Player.UserName); List <RoundPlayerAction> rpas = new List <RoundPlayerAction>(); if (RoundHelper.DetermineIfUserCanWin(round, player, _pointCalculator)) { rpas.Add(new RoundPlayerAction { ActionType = ActionType.Win, ActionStatus = ActionStatus.Inactive }); } if (DetermineIfUserCanKongFromBoard(userTiles, boardActiveTile)) { rpas.Add(new RoundPlayerAction { ActionType = ActionType.Kong, ActionStatus = ActionStatus.Inactive }); } if (DetermineIfUserCanPong(userTiles, boardActiveTile)) { rpas.Add(new RoundPlayerAction { ActionType = ActionType.Pong, ActionStatus = ActionStatus.Inactive }); } if (player.GamePlayer.Player.UserName == nextPlayer.GamePlayer.Player.UserName) { var nextPlayerTiles = round.RoundTiles.Where(rt => rt.Owner == nextPlayer.GamePlayer.Player.UserName); if (DetermineIfUserCanChow(nextPlayerTiles, boardActiveTile)) { rpas.Add(new RoundPlayerAction { ActionType = ActionType.Chow, ActionStatus = ActionStatus.Inactive }); } } if (rpas.Count() > 0) { foundActionForUser = true; foreach (var pa in rpas) { player.RoundPlayerActions.Add(pa); } } } return(foundActionForUser); }