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 CalculatePoints([Values(1)] int input, [Values(1)] int deckCount,
[Values("Denis")] string clientName)
{
Game game = new Game();
game.NewGame();
Croupier croupier = new Croupier(1);
croupier.TakeCard(new Card()
{
Name = "5", Suit = "Heart", Value = 5
});
croupier.TakeCard(new Card()
{
Name = "T", Suit = "Heart", Value = 11
});
croupier.TakeCard(new Card()
{
Name = "T", Suit = "Heart", Value = 11
});
croupier.TakeCard(new Card()
{
Name = "T", Suit = "Heart", Value = 11
});
croupier.TakeCard(new Card()
{
Name = "10", Suit = "Heart", Value = 10
});
Assert.AreEqual(18, croupier.CalculatePoints());
}
public void SpinRouletteTest()
{
Croupier croupier = new Croupier(roulette);
croupier.spinRoulette();
Assert.IsTrue(croupier.getRouletteNumber() == 7);
}
private int CheckWinner(Croupier croupier, Player player)
{
// return 2 -> Draw
// return 1 -> Player Wins
// return 0 -> Croupier wins
int CrPnt = croupier.Points; // Croupiter Points
int PlPnt = player.Points; // Player Points
if (PlPnt > 21 && CrPnt > 21)
{
return(2);
}
else if (PlPnt > 21 && CrPnt <= 21) // croupier wins
{
return(0);
}
else if (PlPnt <= 21 && CrPnt > 21) // player wins
{
return(1);
}
else if (PlPnt == CrPnt) // draw
{
return(2);
}
else if (PlPnt > CrPnt) // Player wins
{
return(1);
}
else // Croupier wins
{
return(0);
}
}
public void SetUp()
{
_a0 = new Apostador("Susana", 1000);
_a0.Silla = 0;
_a1 = new Apostador("Maria", 1000);
_a1.Silla = 1;
_a1.IniciaMano(100);
_a1.RecibeCarta(new Carta(Carta.Valor.Nueve, Carta.Palo.Diamantes));
_a2 = new Apostador("Juan", 1000);
_a2.Silla = 2;
_a2.IniciaMano(200);
_a2.RecibeCarta(new Carta(Carta.Valor.Rey, Carta.Palo.Diamantes));
_a2.RecibeCarta(new Carta(Carta.Valor.As, Carta.Palo.Treboles));
_c0 = new Croupier();
_c1 = new Croupier();
_c1.IniciaMano();
_c1.RecibeCarta(new Carta(Carta.Valor.Nueve, Carta.Palo.Diamantes));
_c2 = new Croupier();
_c2.IniciaMano();
_c2.RecibeCarta(new Carta(Carta.Valor.Rey, Carta.Palo.Diamantes));
_c2.RecibeCarta(new Carta(Carta.Valor.As, Carta.Palo.Treboles));
}
public void CartasMandatorias_1()
{
IJogador jogador = new DummyJogadorTHB(DealerPartidaTest.configPadrao);
Carta[] cartasJogador = new Carta[] {
new Carta(10, Enuns.Naipe.Copas),
new Carta(10, Enuns.Naipe.Paus)
};
IJogador banca = new Banca(DealerPartidaTest.configPadrao);
Comum.Mesa m = new Comum.Mesa(DealerPartidaTest.configPadrao);
int quantidadeJogos = 5;
CroupierConstructParam param = new CroupierConstructParam()
{
CartasJogador = cartasJogador,
Jogador = jogador,
Banca = banca,
ConfiguracaoPoker = DealerPartidaTest.configPadrao
};
ICroupier croupier = new Croupier(param);
for (int i = 0; i < quantidadeJogos; i++)
{
croupier.ExecutarNovaPartidaCompleta();
IPartida p = jogador.Historico.Last();
Assert.IsTrue(p.Jogador.Cartas.Contains(cartasJogador[0]) && p.Jogador.Cartas.Contains(cartasJogador[1]));
}
}
public void getStackSaldoFinalTest()
{
ConfiguracaoTHBonus config = Configuracao.configPadrao;
Comum.Mesa m = new Comum.Mesa(config);
ICroupier dealer = new Croupier(m, new Banca(config));
IJogador j = new DummyJogadorTHB(config, 1500);
m.AddParticipante(j);
int stackInicial = 1500, stackFinal = 1500, saldoFinal = 0;
int qtdPerdida = 0, qtdGanho = 0, qtdEmpate = 0, numJogos = 100;
for (int i = 0; i < numJogos; i++)
{
dealer.ExecutarNovaPartidaCompleta();
}
qtdPerdida = j.Historico.Where(x => x.JogadorGanhador == Enuns.VencedorPartida.Banca).Count();
qtdGanho = j.Historico.Where(x => x.JogadorGanhador == Enuns.VencedorPartida.Jogador).Count();
qtdEmpate = j.Historico.Where(x => x.JogadorGanhador == Enuns.VencedorPartida.Empate).Count();
stackFinal -= (15 * qtdPerdida);
stackFinal += (10 * qtdGanho);
saldoFinal = (stackFinal - stackInicial);
Assert.IsTrue(saldoFinal == j.Estatistica.getStackSaldoFinal());
}
static void Main(string[] args)
{
Wheel wheel = new Wheel();
Croupier croupier = new Croupier(wheel);
croupier.SpinWheel();
}
public void betEvenTest()
{
Croupier croupier = new Croupier(roulette);
croupier.betEven(gambler, 778899);
Assert.IsTrue(croupier.BetOnEven.ContainsKey(gambler));
Assert.IsTrue(croupier.BetOnEven.ContainsValue(778899));
}
public Game(List <Player> players, int countOfDecks = 8)
{
Players = players;
drawer = new Drawer();
Croupier = new Croupier();
Machine = new ShuffleMachine(countOfDecks);
Machine.Shuffle();
}
public Game(PlayerChoise pc, Random r)
{
rand = r;
Doors = InitDoors();
PlayerChoise = pc;
player = new Player();
croupier = new Croupier();
}
private bool CheckBJ(Croupier croupier) // overload
{
if (croupier.Hand.Count == 2 && croupier.Points == 21)
{
return(true);
}
return(false);
}
public void WriteCroupierCards(Croupier croupier)
{
Console.Write("\nDealer has the cards: ");
foreach (Card card in croupier.Hand.Cards)
{
Console.Write(card.GetName() + " ");
}
Console.WriteLine("(" + croupier.Hand.CountPoints() + " points)\n");
}
public void CroupierPlayTest()
{
var croupier = new Croupier();
var shoes = new Shoes();
croupier.Play(shoes);
Assert.IsTrue(croupier.HandValue >= 17);
Assert.AreEqual(416 - croupier.Hand.Count, shoes.AllCardsCount);
}
public void CanCreateGameWithTwoDice()
{
var croupier = new Croupier();
var casino = new Casino();
var game = croupier.CreateTwoDiceGame(casino);
Assert.AreEqual(2, game.RollCount);
}
public IList <ISimulacaoCallPreFlop> GeraListaGanhosPerdas(int idGrupo)
{
IList <IMaoBasica> listaMao = MaoBasica.GetTodasMaosPossiveis();
IList <ISimulacaoCallPreFlop> listaSimulacao = new List <ISimulacaoCallPreFlop>();
IJogador banca = new Banca(this.Config);
IRetornaProbabilidade retornaProbabilidade = new RecuperarProbabilidade();
Comum.Mesa m = new Comum.Mesa(this.Config);
IList <IMaoBasica> novaMao = new List <IMaoBasica>();
//foreach (IMaoBasica mao in listaMao)
// if (mao.NumCarta1 > 10) novaMao.Add(mao);
//listaMao = novaMao;
foreach (IMaoBasica mao in listaMao)
{
ISimulacaoCallPreFlop simulacao = new SimulacaoCallPreFlop()
{
IdGrupo = idGrupo,
ProbabilidadeMaoInicial = ProbabilidadeMaoInicialContext.GetItem(mao),
MaoBasica = mao,
QuantidadeJogosSimuladosPretendidos = this.QuantidadeJogosSimuladosPretendidos,
StackInicial = this.StackInicial,
QuantidadeJogosSimulados = 0,
QuantidadeJogosGanhos = 0,
QuantidadeJogosPerdidos = 0,
QuantidadeJogosEmpatados = 0,
RaiseFlop = false,
RaiseFlopTurn = false
};
IJogador jogador = new JogadorProbabilistico(
this.Config,
this.GetAcaoProbabilidade(simulacao.ProbabilidadeMaoInicial),
retornaProbabilidade,
this.StackInicial
);
ICroupier croupier = new Croupier(new CroupierConstructParam()
{
Jogador = jogador,
Banca = banca,
ConfiguracaoPoker = this.Config
}
);
simulacao = this.SimulaJogosUmaMao(simulacao, croupier, jogador);
SimulacaoCallPreFlopProbabilidadeContext.Persiste(simulacao);
Console.WriteLine(mao.NumCarta1 + " " + mao.NumCarta2 + " - " + mao.OffOrSuited);
}
return(listaSimulacao);
}
public void BeginGameTest()
{
Game game = new Game();
Croupier croupier = new Croupier(game);
croupier.BeginGame();
Assert.AreEqual(croupier.Hand.Cards.Count, 2);
Assert.Pass();
}
public void GiveCards([Values(1)] int input, [Values(1)] int deckCount,
[Values("Denis")] string clientName)
{
Game game = new Game();
game.NewGame();
Croupier croupier = new Croupier(1);
// Assert.AreEqual("2", croupier.GiveCards(input).First().Name);
}
public void SpinRouletteTest()
{
Mock <IRoulette> mockRoulette = new Mock <IRoulette>();
IRoulette roulette = mockRoulette.Object;
mockRoulette.Setup(r => r.Spin()).Returns(7);
Croupier croupier = new Croupier(roulette);
croupier.spinRoulette();
Assert.IsTrue(croupier.getRouletteNumber() == 7);
}
public ActionResult RecibirApuesta(int Elegido, ApuestaViewModel[] apostado)
{
Croupier c = Session["game"] as Croupier;
c.Elegido = Elegido;
List <Casillero> numeros = new List <Casillero>();
Casillero casilla;
Apuesta bet;
foreach (var item in apostado)
{
foreach (var num in item.numeros)
{
casilla = new Casillero();
casilla.Valor = num;
if (num < 37)
{
casilla.Color = c.Ruleta.tablero[num].Color;
}
numeros.Add(casilla);
}
bet = new Apuesta(new List <Casillero>(numeros), item.fichas, new Modalidad(item.modalidad), c.Jugador);
c.Ruleta.Apostar(bet);
numeros.Clear();
}
int pagar = c.Pagar();
bool gano = false;
if (pagar > 0)
{
gano = true;
}
c.Jugador.Guardar(c.Jugador.Id, pagar);
c.Jugador = c.Jugador.Buscar(c.Jugador.User, c.Jugador.Pass);
Session["game"] = c;
var json = Json(new
{
nombre = c.Jugador.Nombre,
apellido = c.Jugador.Apellido,
fichas = c.Jugador.Fichas,
victorias = c.Jugador.Victorias,
jugadas = c.Jugador.Jugadas,
gano = gano,
salio = Elegido,
color = c.Ruleta.tablero[Elegido].Color,
});
return(Json(json));
}
public Game()
{
Client = new Client(this);
Croupier = new Croupier(this, _rnd.Next(0, 3));
SetupState = new SetupState(this);
StartState = new StartState(this);
GettingCardsState = new GettingCardsState(this);
ComparePointsState = new ComparePointsState(this);
EndGameState = new EndGameState(this);
_currentState = SetupState;
}
/*--------------------------------------------------------------
* /
* /---------------------------------------------------------------*/
public void InsereEtape()
{
DateTime DateIns = DateTime.Now;
PA.InitJoueurs();
for (int i = 0; i < PA.Joueurs.Count; i++)
{
if (PA.Joueurs[i].Decision != "PETIT_BLIND" &&
PA.Joueurs[i].Decision != "GROS_BLIND" &&
PA.Joueurs[i].Decision != "ABANDONNER" &&
PA.Joueurs[i].Decision != "Muet" &&
PA.Joueurs[i].Decision != "MORT" &&
PA.Joueurs[i].Decision != "MOURANT" &&
PA.Joueurs[i].Decision != "ALL_IN_SUIVRE" &&
PA.Joueurs[i].Decision != "ALL_IN_RELANCER")
{
PA.Joueurs[i].Decision = "Attente";
}
}
PA.Num_Tour = 1;
string[] TabDD = new string[6];
int[] TabEng = new int[6];
int[] TabK = new int[6];
for (int i = 0; i < PA.Joueurs.Count; i++)
{
if (PA.Joueurs[i].Decision == null)
{
TabDD[i] = "MORT";
}
else
{
TabDD[i] = PA.Joueurs[i].Decision;
}
TabEng[i] = PA.Joueurs[i].Engagement;
TabK[i] = PA.Joueurs[i].Capital;
}
Croupier croupier = new Croupier(TabDD, TabEng, TabK, PA.JoueurLogue, PA.Etape, PA.Bouton);
string context = "CHANGEMENT_ETAPE";
if (PA.Etape == "PRE_FLOP")
{
context = "NOUVELLE_MAIN";
}
PA.ProchainJoueur = croupier.DetermineProchainJoueur(context);
string ins = "insert into etapes values( " + PA.Numero + ", " + PA.Numero_Main + ", '" + PA.Etape + "', " + PA.ProchainJoueur + ", '" + DateTime.Now + "', " + PA.Num_Tour + ")";
maBD.Commande(ins);
TG.SRV.Incarne <ToursParole_ADO_SRV>().InsereTourParole();
}
public void ComparePoints([Values(19)] int clientPoints)
{
Croupier croupier = new Croupier(1);
croupier.TakeCard(new Card()
{
Name = "T", Suit = "Heart", Value = 11
});
croupier.TakeCard(new Card()
{
Name = "Q", Suit = "Heart", Value = 10
});
Assert.AreEqual("LOSE!", croupier.ComparePoints(clientPoints));
}
public ActionResult Login(string username, string password)
{
Player player = new Player();
if (player.ValidarLogin(username, password))
{
Session["game"] = new Croupier(player.Buscar(username, password));
return(RedirectToAction("Index", "Home"));
//return View();
}
else
{
return(RedirectToAction("ErrorLogin", "Cuenta"));
}
}
public void getStackInicialTest()
{
ConfiguracaoTHBonus config = Configuracao.configPadrao;
Comum.Mesa m = new Comum.Mesa(config);
ICroupier dealer = new Croupier(m, new Banca(config));
IJogador j = new DummyJogadorTHB(config, 1500);
m.AddParticipante(j);
int stackInicial = 1500;
dealer.ExecutarNovaPartidaCompleta();
Assert.IsTrue(stackInicial == j.Estatistica.getStackInicial());
}
public ActionResult Comprar(int fichas)
{
Croupier c = Session["game"] as Croupier;
c.Jugador.Comprar(c.Jugador.Id, fichas);
c.Jugador = c.Jugador.Buscar(c.Jugador.User, c.Jugador.Pass);
Session["game"] = c;
var json = Json(new
{
fichas = c.Jugador.Fichas,
dinero = c.Jugador.Efectivo
});
return(Json(json));
}
public void SpinRouletteTest()
{
// create a mockup of the roulette
Mock <Roulette> mockRoulette = new Mock <Roulette>();
// get a mock roullet object
Roulette roulette = mockRoulette.Object;
// create a mock spin method in mock roulette (will always return 7 when you call spin method)
mockRoulette.Setup(r => r.spin()).Returns(7);
// create Crouper
Croupier croupier = new Croupier(roulette);
croupier.spinRoulette();
Assert.IsTrue(croupier.getRouletteNumber() == 7);
}
//
// GET: /Home/
public ActionResult Index()
{
HomeViewModel vm = new HomeViewModel();
Croupier c = Session["game"] as Croupier;
vm.dinero = c.Jugador.Efectivo;
vm.fichas = c.Jugador.Fichas;
vm.partidas = c.Jugador.Jugadas;
vm.victorias = c.Jugador.Victorias;
vm.nombre = c.Jugador.Nombre;
vm.apellido = c.Jugador.Apellido;
vm.email = c.Jugador.Email;
vm.avatar = c.Jugador.Avatar;
vm.user = c.Jugador.User;
// este action es para comprar fichas
return(View(vm));
}
internal IPartida GetBancaGanhou()
{
uint stackInicialJogador = 20000;
Comum.Mesa m = new Comum.Mesa(this.ConfiguracaoPadrao);
ICroupier dealer = new Croupier(m, new Banca(this.ConfiguracaoPadrao));
IJogador jogador = new DummyJogadorTHB(this.ConfiguracaoPadrao, stackInicialJogador);
m.AddParticipante(jogador);
dealer.ExecutarNovaPartidaCompleta();
while (dealer.HaParticipantesParaJogar() && jogador.Historico.Last().JogadorGanhador != Enuns.VencedorPartida.Banca)
{
dealer.ExecutarNovaPartidaCompleta();
}
return(jogador.Historico.Last());
}
public void getQuantidadeJogosJogadosTest()
{
ConfiguracaoTHBonus config = Configuracao.configPadrao;
Comum.Mesa m = new Comum.Mesa(config);
int numeroPartidas = 5;
ICroupier dealer = new Croupier(m, new Banca(config));
IJogador j = new DummyJogadorTHB(config);
m.AddParticipante(j);
dealer.ExecutarNovaPartidaCompleta();
dealer.ExecutarNovaPartidaCompleta();
dealer.ExecutarNovaPartidaCompleta();
dealer.ExecutarNovaPartidaCompleta();
dealer.ExecutarNovaPartidaCompleta();
Assert.IsTrue(numeroPartidas == j.Estatistica.getQuantidadeJogosJogados());
}
