Ejemplo n.º 1
0
        /// <summary>
        /// Inicia rodada enquanto há a quantidade mínima de jogadores ativos na mesa
        /// </summary>
        public string IniciarMao()
        {
            if (PreFlopExecutado || FlopExecutado || TurnExecutado || RiverExecutado)
            {
                throw new Exception(Ressource.MesaMsgPreFlopExecutadoAposOutraJogadaDeMesa);
            }

            if (JogadoresAtivos.Count() < _quantidadeMinimaDeJogadoresPermitidos)
            {
                throw new Exception(Ressource.MesaMsgNaoPermitidoIniciarRodadaSemQuantidadeMinimaDeJogadores);
            }

            Baralho = new Baralho();

            for (int i = 0; i < 2; i++)
            {
                foreach (var jogador in JogadoresAtivos)
                {
                    jogador.ReceberCarta(Baralho.DistribuirCarta());
                }
            }

            if (IdJogadorSmallBlind != 0)
            {
                OrdenarJogadores(IdJogadorSmallBlind);
                Jogadores.MoveFirstItemToFinal <Jogador>();
            }

            IdJogadorSmallBlind = JogadoresAtivos.First().Id;

            var mensagem = "";

            //Receber Small Blind
            TentarIndicarProximoJogador();
            mensagem = ReceberAposta(ValorBlind / 2, "small");

            //Receber Big Blind
            TentarIndicarProximoJogador();
            mensagem += $"\r\n{ReceberAposta(ValorBlind, "big")}";

            ApostaAtual = ValorBlind;

            // Se houver mais do que dois jogadores pega a terceira posição da lista, caso contrário a segunda posição
            IdJogadorUTG = JogadoresAtivos[JogadoresAtivos.Count > 2 ? 2 : 0].Id;

            // Posiciona o UTG como primeiro da lista
            OrdenarJogadores(IdJogadorUTG);
            JogadorAtual     = null;
            PreFlopExecutado = true;

            return(mensagem);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Verifica se há algum jogador ainda para jogar na rodada.
        /// Caso haja jogador pendente de ação, a propriedade JogadorAtual será preenchida com o objeto deste jogador, caso contrário, a propriedade será preenchida com null.
        /// </summary>
        /// <returns>Retorna true enquanto há jogadores pendentes, caso contrário false.</returns>
        public bool TentarIndicarProximoJogador()
        {
            if (JogadorAtual == null)
            {
                JogadorAtual = JogadoresAtivos[0];
                return(true);
            }
            else
            {
                var indiceProximoJogador = JogadoresAtivos.FindIndex(j => j.Id == JogadorAtual.Id) + 1;

                if (indiceProximoJogador < JogadoresAtivos.Count())
                {
                    JogadorAtual = JogadoresAtivos[indiceProximoJogador];
                    return(true);
                }
                else
                {
                    JogadorAtual = null;
                    return(false);
                }
            }
        }