Ejemplo n.º 1
0
        public bool SetGameVariant(int playerId, GamesVariants variant)
        {
            if (variant == GamesVariants.None)
            {
                return(false);
            }

            var tablePlayer = GettablePlayerOfId(playerId);

            if (tablePlayer != null && tablePlayer.GameVariant == GamesVariants.None)
            {
                // change the variant of the player
                tablePlayer.GameVariant = variant;
                tablePlayer.NextTurn    = true;
                _context.TablePlayer.Update(tablePlayer);
                _context.SaveChanges();

                // check if all players has set game variant and set the table variant with status
                var tablePlayers          = GetPlayersOfTable(tablePlayer.TableId);
                var playerSetVariantCount = tablePlayers.Count((player) => player.GameVariant != GamesVariants.None);

                if (playerSetVariantCount == 4)
                {
                    PlayTable table = GetTableById(tablePlayer.TableId);

                    table.GameVariant = CardPointsUtil.WhichVariantIsPlayed(tablePlayers);
                    if (table.GameVariant == GamesVariants.Normal)
                    {
                        table.SilentForPlayer = CardPointsUtil.SilentPlayer(tablePlayers);
                    }

                    table.Status = PlayStatus.Run;
                    _context.Update(table);
                    _context.SaveChanges();
                }
                OnTableChanged(tablePlayer.TableId);
                return(true);
            }
            return(false);
        }
Ejemplo n.º 2
0
        public static GamesVariants WhichVariantIsPlayed(TablePlayer[] tablePlayers)
        {
            GamesVariants playedVariant = GamesVariants.Normal;
            int           weighting     = 50;

            foreach (var player in tablePlayers)
            {
                int           weightingbuffer = 50;
                GamesVariants variantBuff;
                switch (player.GameVariant)
                {
                case GamesVariants.ColoRSoloClubs:
                    weightingbuffer = 0;
                    variantBuff     = GamesVariants.ColoRSoloClubs;
                    break;

                case GamesVariants.ColoRSoloSpades:
                    weightingbuffer = 1;
                    variantBuff     = GamesVariants.ColoRSoloSpades;
                    break;

                case GamesVariants.ColoRSoloHearts:
                    weightingbuffer = 2;
                    variantBuff     = GamesVariants.ColoRSoloHearts;
                    break;

                case GamesVariants.ColorSoloDiamonds:
                    weightingbuffer = 3;
                    variantBuff     = GamesVariants.ColorSoloDiamonds;
                    break;

                case GamesVariants.Solo:
                    weightingbuffer = 4;
                    variantBuff     = GamesVariants.Solo;
                    break;

                case GamesVariants.AceSolo:
                    weightingbuffer = 5;
                    variantBuff     = GamesVariants.AceSolo;
                    break;

                case GamesVariants.KingSolo:
                    weightingbuffer = 6;
                    variantBuff     = GamesVariants.KingSolo;
                    break;

                case GamesVariants.QueenSolo:
                    weightingbuffer = 7;
                    variantBuff     = GamesVariants.QueenSolo;
                    break;

                case GamesVariants.JackSolo:
                    weightingbuffer = 8;
                    variantBuff     = GamesVariants.JackSolo;
                    break;

                case GamesVariants.Wedding:
                    weightingbuffer = 9;
                    variantBuff     = GamesVariants.Wedding;
                    break;

                default:
                    weightingbuffer = 10;
                    variantBuff     = GamesVariants.Normal;
                    break;
                }
                if (weightingbuffer < weighting)
                {
                    weighting     = weightingbuffer;
                    playedVariant = variantBuff;
                }
            }

            return(playedVariant);
        }