public void PerguntarPagarFlop()
{
foreach (var jog in this.Mesa.PartidasAtuais)
{
IPartida partida = jog.Value;
IJogador jogador = jog.Key;
IJogador banca = partida.Banca;
IRodada rodadaAtual = partida.Rodadas.Last();
IRodada proximaRodada;
IAcaoTomada acaoTomada = jogador.PreFlop(this.Mesa.RegrasMesaAtual.Flop);
rodadaAtual.AddAcaoTomada(acaoTomada);
switch (acaoTomada.Acao)
{
case AcoesDecisaoJogador.PayFlop:
partida.AddToPote(jogador.PagarValor(this.Mesa.RegrasMesaAtual.Flop), TipoJogadorTHB.Jogador);
partida.AddToPote(banca.PagarValor(this.Mesa.RegrasMesaAtual.Flop), TipoJogadorTHB.Banca);
proximaRodada = new RodadaTHB(TipoRodada.Flop, partida.PoteAgora, partida.CartasMesa);
break;
case AcoesDecisaoJogador.Fold:
proximaRodada = new RodadaTHB(TipoRodada.FimDeJogo, partida.PoteAgora, partida.CartasMesa);
partida.JogadorGanhador = VencedorPartida.Banca;
break;
default:
throw new Exception("Ação não esperada.");
}
partida.AddRodada(proximaRodada);
}
this.EncerrarPartidasTerminadas();
}
public void EncerrarPartidaJogador(IJogador j)
{
IPartida partidaAtual = this.Mesa.PartidasAtuais[j];
j.AddPartidaHistorico(this.Mesa.PartidasAtuais[j]);
this.Mesa.PartidasAtuais.Remove(j);
}
internal override IJogador CalcularVencedor()
{
var jogadores = ListarJogadores();
var grupos = jogadores.Select(a => a.GrupoJogada).Distinct();
List <IJogador> vencedoresProximaRodada = new List <IJogador>();
List <IJogador> vencedoresGrupos = new List <IJogador>();
foreach (var grupo in grupos)
{
var jogadoresGrupoAtual = jogadores.Where(a => a.GrupoJogada == grupo).ToArray();
var vencedoresGrupoAtual = jogadoresGrupoAtual;
while (vencedoresGrupoAtual.Count() > 1)
{
for (int i = 0; i < vencedoresGrupoAtual.Count(); i += 2)
{
IJogador ganhadorJogada = ExecutorRodada.RealizarJogada(vencedoresGrupoAtual[i], vencedoresGrupoAtual[i + 1]);
vencedoresProximaRodada.Add(ganhadorJogada);
}
vencedoresGrupoAtual = vencedoresProximaRodada.ToArray();
vencedoresProximaRodada.Clear();
}
vencedoresGrupos.Add(vencedoresGrupoAtual.First());
}
IJogador vencedorCampeonato = vencedoresGrupos.Count() > 1 ? ExecutorRodada.RealizarJogada(vencedoresGrupos[0], vencedoresGrupos[1]) : vencedoresGrupos[0];
return(vencedorCampeonato);
}
public void PerguntarAumentarPreRiver()
{
foreach (var jog in this.Mesa.PartidasAtuais)
{
IJogador jogador = jog.Key;
IPartida partida = jog.Value;
IJogador banca = partida.Banca;
IAcaoTomada acaoJogador = jogador.Turn(jog.Value.CartasMesa, 0);
switch (acaoJogador.Acao)
{
case AcoesDecisaoJogador.Check:
partida.AddRodada(new RodadaTHB(TipoRodada.River, partida.PoteAgora, partida.CartasMesa));
break;
case AcoesDecisaoJogador.Call:
partida.AddToPote(jogador.PagarValor(this.Mesa.RegrasMesaAtual.River), TipoJogadorTHB.Jogador);
partida.AddToPote(banca.PagarValor(this.Mesa.RegrasMesaAtual.River), TipoJogadorTHB.Banca);
partida.AddRodada(new RodadaTHB(TipoRodada.River, partida.PoteAgora, partida.CartasMesa));
break;
case AcoesDecisaoJogador.Raise:
partida.AddToPote(jogador.PagarValor(this.Mesa.RegrasMesaAtual.River), TipoJogadorTHB.Jogador);
partida.AddToPote(banca.PagarValor(this.Mesa.RegrasMesaAtual.River), TipoJogadorTHB.Banca);
partida.AddRodada(new RodadaTHB(TipoRodada.River, partida.PoteAgora, partida.CartasMesa));
break;
default: throw new Exception("Ação não esperada.");
}
}
this.EncerrarPartidasTerminadas();
}
public ISimulacaoJogosResumo SimulaJogos(IJogador jogador, IAcaoProbabilidade acao = null)
{
ISimulacaoJogosResumo simulacao = new SimulacaoJogosResumo()
{
QuantidadeJogosSimuladosPretendidos = this.QuantidadeJogosSimuladosPretendidos,
StackInicial = this.StackInicial,
QuantidadeJogosSimulados = 0,
QuantidadeJogosGanhos = 0,
QuantidadeJogosPerdidos = 0,
QuantidadeJogosEmpatados = 0,
DescricaoInteligencia = "Foge se não tiver chance vencer maior que 50% em qualquer decisão tomada",
StackFinal = 0,
AcaoProbabilidade = acao
};
IJogador banca = new Banca(this.Config);
Comum.Mesa m = new Comum.Mesa(this.Config);
ICroupier croupier = new Croupier(new CroupierConstructParam()
{
Jogador = jogador,
Banca = banca,
ConfiguracaoPoker = this.Config
}
);
simulacao = this.GeraUmaSimulacao(simulacao, croupier, jogador);
return(simulacao);
}
public void SimulaJogosResumoPersiste(int quantidadeSimulacoes, IJogador jogador)
{
for (int i = 0; i < quantidadeSimulacoes; i++)
{
ISimulacaoJogosResumo s = this.SimulaJogos(jogador);
this.PersisteSimulacao(s);
}
}
/// <summary>
/// Retira jogador da mesa.
/// </summary>
/// <param name="j">Jogador a sair.</param>
public void RetirarJogadorDaMesa(IJogador j)
{
if (!this.Mesa.JogadoresNaMesa.Contains(j))
{
throw new DealerException("Tentando retirar jogador que não está na mesa.");
}
this.Mesa.JogadoresNaMesa.Remove(j);
}
public IBuilderSitAndGo addJogador(uint quantidadePartidasExecutar, IJogador jogador)
{
IJogador Jogador = jogador;
Jogador.Corrida = new Corrida(quantidadePartidasExecutar);
this.Jogadores.Add(Jogador);
return(this);
}
public IBuilderSitAndGo SetBanca(IJogador jogador)
{
// Dealer Mesa
if (this.Banca == null)
{
this.Banca = jogador;
}
return(this);
}
public void Calcula(IJogador jogador, IJogador banca)
{
ISitAndGo SitAndGo =
new BuilderSitAndGo(new ConfiguracaoTHBonus())
.addJogador(jogador)
.SetBanca(banca)
.ToSitAndGo();
SitAndGo.Executa();
}
internal virtual void IncluirJogada(IJogador jogador)
{
if (QuantidadeJogadoresPermitidos.HasValue && !PermiteMaisJogadores())
{
throw new QuantidadeJogadoresException("Capacidade de jogadores esgotada!");
}
QuantidadeJogadoresParticipantes++;
_jogadores.Add(jogador);
}
/// <summary>
/// Inicia um SitAndGo.
/// </summary>
/// <param name="configuracaoPoker">Valors da configuração</param>
/// <param name="Banca">O Jogador que representa a Banca.</param>
public SitAndGo(IConfiguracaoPoker configuracaoPoker, IJogador Banca, IJogador Jogador)
{
//todo: retirar a banca do parâmetro, para ficar desacoplado
this.ConfiguracaoPoker = configuracaoPoker;
this.Mesa = new Mesa(this.ConfiguracaoPoker);
this.Jogadores = new List <IJogador>()
{
Jogador
};
this.Croupier = new Croupier(this.Mesa, Banca, Jogador);
}
internal IList <IPartida> GetJogadorGanhou(int numPartidasRetornadas, IJogador j = null)
{
IList <IPartida> retorno = new List <IPartida>();
for (int i = 0; i < numPartidasRetornadas; i++)
{
retorno.Add(this.GetJogadorGanhou(j));
}
return(retorno);
}
internal override IJogador CalcularVencedor()
{
var jogadores = ListarJogadores();
if (jogadores.Count != QuantidadeJogadoresPermitidos)
{
throw new QuantidadeJogadoresException(String.Format("Quantidade de jogadores diferente de {0}!", QuantidadeJogadoresPermitidos));
}
IJogador vencedor = ExecutorRodada.RealizarJogada(jogadores[0], jogadores[1]);
return(vencedor);
}
private void DistribuiCartas(IJogador jogador, Carta[] CartasMandatorias, IPartida p)
{
if (CartasMandatorias != null && CartasMandatorias.Length > 0)
{
if (CartasMandatorias.Length == 1)
{
jogador.ReceberCarta(CartasMandatorias[0].Clone(), p.PopDeck());
}
else
{
jogador.ReceberCarta(CartasMandatorias[0].Clone(), CartasMandatorias[1].Clone());
}
}
else
{
jogador.ReceberCarta(p.PopDeck(), p.PopDeck());
}
}
internal IPartida GetJogadorGanhou(IJogador j = null)
{
uint stackInicialJogador = 20000;
Comum.Mesa m = new Comum.Mesa(this.ConfiguracaoPadrao);
IJogador banca = new Banca(this.ConfiguracaoPadrao);
ICroupier dealer = new Croupier(m, banca);
dealer.DealerPartida = new DealerPartidaMock(m, banca, Enuns.VencedorPartida.Jogador);
IJogador jogador = j ?? new DummyJogadorTHB(this.ConfiguracaoPadrao, stackInicialJogador);
m.AddParticipante(jogador);
dealer.ExecutarNovaPartidaCompleta();
//while(jogador.Historico.Last().JogadorGanhador != Enuns.VencedorPartida.Jogador)
// dealer.ExecutarNovaPartidaCompleta();
return(jogador.Historico.Last());
}
internal IJogador RealizarJogada(IJogador jogador01, IJogador jogador02)
{
IJogador vencedorRodada = null;
if (jogador01.TipoJogada == jogador02.TipoJogada)
{
return(jogador01);
}
switch (jogador01.TipoJogada)
{
case TipoJogada.Pedra:
if (jogador02.TipoJogada == TipoJogada.Tesoura)
{
vencedorRodada = jogador01;
}
break;
case TipoJogada.Papel:
if (jogador02.TipoJogada == TipoJogada.Pedra)
{
vencedorRodada = jogador01;
}
break;
case TipoJogada.Tesoura:
if (jogador02.TipoJogada == TipoJogada.Papel)
{
vencedorRodada = jogador01;
}
break;
default:
vencedorRodada = jogador02;
break;
}
return(vencedorRodada ?? jogador02);
}
public JogoFERA(IJogador jogador1,
IJogador jogador2)
{
this._jogador1 = jogador1;
this._jogador2 = jogador2;
}
public JogoFODA(IJogador jogador1, IJogador jogador2)
{
_jogador1 = jogador1;
_jogador2 = jogador2;
}
public JogoFODA(IJogador jogador1, IJogador jogador2)
{
_jogadorA = jogador1;
_jogadorB = jogador2;
}
public JogoFODA(IJogador jogador1)
{
_jogador1 = jogador1;
}
/// <summary>
/// Solicita a primeira carta para o baralho utilizando padrão command. tem o jogador da vez como parametro
/// </summary>
private void ComprarCarta(IJogador j)
{
this.comando = new ComprarCartaCommand(this.Baralho);
j.setCommand(comando);
j.EnviaComand();
}
//todo: retirar banca e instanciar como padrão
public DealerPartida(Mesa mesa, IJogador Banca, Carta [] MaoBanca = null, Carta[] MaoJogador = null)
{
this.Mesa = mesa;
this.banca = Banca;
this.SetMaosPreferenciais(MaoBanca, MaoJogador);
}
public JogoFoda(IJogador jogadorA, IJogador jogadorB)
{
this._jogadorA = jogadorA;
this._jogadorB = jogadorB;
}
private void Valida(IJogador j, Carta c)
{
JogoHelper.Show(String.Format(Instrucoes.JogadaMaquina ,c.ToString()));
if (this.CartaLancada.Naipe == c.Naipe)
{
j.MinhasCartas.Remove(c);
this.CartaLancada = null;
ChamaDesafio d = estado == EstadoJogadasEnum.JogadorTentacobrirDesafio ? new ChamaDesafio(this.Desafiar) : new ChamaDesafio(this.MaquinaDesafia);
d();
}
else
{
ChamaDesafio d = estado == EstadoJogadasEnum.JogadorTentacobrirDesafio ? new ChamaDesafio(this.Desafio) : new ChamaDesafio(this.JogaMaquina);
d();
}
}
public JogoFoda(IJogador jogador1, IJogador jogador2)
{
_jogador1 = jogador1;
_jogador2 = jogador2;
}
public jogoFoda(IJogador iJogador, IJogador iJogador2)
{
_iJogador = iJogador;
_iJogador2 = iJogador2;
}
public JogoFoda(IJogador jogadorA, IJogador jogadorB)
{
_jogadorA = jogadorA;
_jogadorB = jogadorB;
}
public JogoFIFA(IJogador jogador)
{
_jogador = jogador;
}
public JogoFODA(IJogador jogadorA, IJogador jogadorB)
{
_jogadorA = jogadorA;
_jogadorB = jogadorB;
}
public Jogo(IJogador jogador1, IJogador jogador2)
{
this.jogador1 = jogador1;
this.jogador2 = jogador2;
}
public JogoFODA(IJogador jogador1, IJogador jogador2, IJogador jogador3)
{
_jogador1 = jogador1;
_jogador2 = jogador2;
_jogador3 = jogador3;
}
