void comprarCard()
{
//Compra carta aleatória do baralho
int rn = Random.Range(0, baralho.Count);
GameObject go = new GameObject("numero: " + baralho[rn].numero + ", cor: " + baralho[rn].cor);
go.tag = "piece";
PieceMovement pm = go.AddComponent <PieceMovement>();
pm.numero = baralho[rn].numero;
pm.cor = baralho[rn].cor;
BoxCollider2D bc = go.AddComponent <BoxCollider2D>();
bc.size = new Vector2(1, 2);
bc.isTrigger = true;
SpriteRenderer renderer = go.AddComponent <SpriteRenderer>();
renderer.sortingLayerName = "02";
renderer.sprite = Resources.Load <Sprite>("teste");
Mao bd = GameObject.Find("Mao").GetComponent <Mao>();
baralho.RemoveAt(rn);
bd.AdicionarPeca(go);
//cm.Adicionar(go);
//cm.Posicionar(go);
}
public Jogador(int numero, Mao mao, string nome, bool auto)
{
Numero = numero;
Mao = mao;
Nome = nome;
Auto = auto;
}
public void IniciaJogo()
{
var deck = new Deck();
var mao = new Mao(deck);
var jogador = new Jogador();
var logicaPoker = new LogicaPoker();
var flop = new Mao(deck);
var turn = new Mao(deck);
var river = new Mao(deck);
string[] maoCompleta = new string[7];
var numeroJogadores = ObterNumeroJogadores();
var listaJogadores = jogador.ObterListaDeJogadores(numeroJogadores);
deck.Embaralhar();
mao.PuxarCartas(2);
mao.Sort();
//var novamao =
for (int i = 0; 1 <= maoCompleta.Length; i++)
{
maoCompleta[i] = mao[i];
}
foreach (var itens in listaJogadores)
{
//itens.Mao = mao;
//itens.Score = (int)_logicaPoker.Score(mao);
//itens.MaoDePoker = _logicaPoker.Score(mao);
//Console.WriteLine(String.Format("Jogador: {0}, Mão: {1}, Mão De Poker: {2}",itens.Nome,itens.Mao, Enum.GetName(typeof(MaosDePoker), itens.MaoDePoker)));
}
flop.PuxarCartas(3);
flop.Sort();
var cartasFlop = flop;
turn.PuxarCartas(1);
turn.Sort();
var cartaTurn = turn;
river.PuxarCartas(1);
river.Sort();
var cartaRiver = river;
var vencedor = listaJogadores.OrderByDescending(a => a.Score).FirstOrDefault();
if (!vencedor.Score.Equals((int)MaosDePoker.None))
{
Console.WriteLine(String.Format("Vencedor: {0} ", vencedor.Nome));
}
Console.WriteLine();
}
/// <summary>
/// Verifica quais são as pedras possíveis de serem jogadas para as pontas informadas
/// </summary>
/// <param name="pEsquerda"></param>
/// <param name="pDireita"></param>
/// <returns></returns>
public List <Pedra> ObterJogadasPossiveis(int pEsquerda, int pDireita)
{
var pontas = new[] { pEsquerda, pDireita };
return(Mao
.Where(p => pontas.Contains(p.Lado1) || pontas.Contains(p.Lado2))
.ToList());
}
/*
* é straight e flush
*/
private static bool EhStraightFlush(Mao h)
{
if (EhStraight(h) && EhFlush(h))
{
return(true);
}
return(false);
}
public void NaoDeveGerarClassificacaoCasoHajaCartasDuplicadas()
{
var cartaBuilderGerada = new CartaBuilder("A;O|K;C", "Q;C|10;C|K;C|8;P|A;O");
var maoGerada = new Mao(cartaBuilderGerada.CartasJogador[0], cartaBuilderGerada.CartasJogador[1]);
string mensagemDeErro = Assert.Throws <Exception>(() => maoGerada.Classificar(cartaBuilderGerada.CartasMesa)).Message;
Assert.Equal($"{Ressource.MaoMsgCartasClassificacaoDuplicadas} A;O|K;C", mensagemDeErro);
}
void Start()
{
mao = GameObject.Find("Mao").GetComponent <Mao>();
turno = false;
pecaSelecionada = null;
primeiraJogada = false;
fazendoMovimento = false;
roundTime = 5;
//FazMovimento();
}
public void DeveClassificarEGerarPontuacaoDaJogada(string cartasJogador, string cartasMesa, long pontuacaoEsperada, string classificacaoEsperada)
{
var cartaBuilderGerada = new CartaBuilder(cartasJogador, cartasMesa);
var maoGerada = new Mao(cartaBuilderGerada.CartasJogador[0], cartaBuilderGerada.CartasJogador[1]);
maoGerada.Classificar(cartaBuilderGerada.CartasMesa);
Assert.Equal(classificacaoEsperada, maoGerada.Classificacao);
Assert.Equal(pontuacaoEsperada, maoGerada.Pontuacao);
}
private static void Main(string[] args)
{
int currentPlayer = 0;
bool reverse = false;
game = new Mao();
game.AddRule(new CustomRule("", RuleResponse.ResponseType.Reverse, RuleResponse.ResponseType.Legal, CustomRule.MatchType.Card, new Card(Suit.Clubs, CardValue.Eight)));
Console.WriteLine("Welcome to Mao");
GetPlayers();
game.Deal();
while (true)
{
Console.WriteLine($"{game.Players[currentPlayer].Name}'s turn:");
Console.WriteLine($"The active card is {game.ActiveCard}");
var card = GetCard(currentPlayer);
var outcome = PlayCard(currentPlayer, card);
foreach (var response in outcome)
{
Console.WriteLine(response.Reason);
if (response.Response == RuleResponse.ResponseType.Reverse)
{
reverse = !reverse;
}
if (response.Penalty != null)
{
game.Players[currentPlayer].Hand.Add(response.Penalty);
}
}
if (reverse)
{
currentPlayer--;
if (currentPlayer < 0)
{
currentPlayer = game.Players.Count - 1;
}
}
else
{
currentPlayer++;
if (currentPlayer == game.Players.Count)
{
currentPlayer = 0;
}
}
}
}
public Carta Eh_Carta_Alta(Mao mao1)
{
Carta maiorCarta = mao1.Cartas.First();
for (int i = 0; i < mao1.Cartas.Count; i++)
{
maiorCarta = DescobreMaiorCarta(maiorCarta, mao1.Cartas[i]);
}
return maiorCarta;
}
/*
* todas as cartas são do mesmo naipe
*/
private static bool EhFlush(Mao h)
{
if (h[0].Naipe == h[1].Naipe &&
h[1].Naipe == h[2].Naipe &&
h[2].Naipe == h[3].Naipe &&
h[3].Naipe == h[4].Naipe)
{
return(true);
}
return(false);
}
public static void ImprimeMao(Mao mao, bool verso, bool posicoes)
{
Linha(mao.QntCartas());
if (mao.Visibilidade == true && verso == true)
{
ImprimeCartas(mao.Cartas, true);
}
else
{
ImprimeCartas(mao.Cartas, false);
}
}
/// <summary>
/// Inicia uma instância da MaoBuilder. Apenas preenche as cartas do jogador
/// </summary>
/// <param name="cartasJogador">Sequência de cartas do jogador separadas por pipe (|)</param>
public MaoBuilder(string cartasJogador)
{
var arrCartasJogador = cartasJogador.Split("|");
var cartas = new List <Carta>();
foreach (var carta in arrCartasJogador)
{
cartas.Add(new Carta(carta));
}
Mao = new Mao(cartas[0], cartas[1]);
}
public static void Player(int indice, JogoPifpaf jogo, bool mostrarInf, bool verso)
{
Mao mao = jogo.Jogadores[indice].Mao;
if (jogo.JogadorAtual.Equals(jogo.Jogadores[indice]))
{
Console.Write(jogo.Jogadores[indice].Numero + "- ");
Console.Write(jogo.Jogadores[indice].Nome);
Print(" << Vez... ", ConsoleColor.DarkCyan);
}
else
{
Console.Write(jogo.Jogadores[indice].Numero + "- " + jogo.Jogadores[indice].Nome + " ");
}
//trincas e sequencias
if (mostrarInf)
{
Console.Write("T " + jogo.Jogadores[indice].Mao.Trincas + " - S " + jogo.Jogadores[indice].Mao.Sequencias);
}
Console.WriteLine();
Linha(jogo.Jogadores[indice].Mao.QntCartas());
//grupos
if (mostrarInf)
{
Console.Write(" ");
foreach (var carta in mao.Cartas)
{
ImprimeGrupo(carta.Grupo);
Console.Write(" ");
}
Console.WriteLine(" ");
}
if (verso)
{
ImprimeCartas(mao.Cartas, true);
}
else
{
ImprimeCartas(mao.Cartas, false);
}
//posicoes
if (mostrarInf)
{
int indiceSelecionado = jogo.Jogadores[indice].Mao.selec;
Posicoes(jogo.Jogadores[indice].Mao.QntCartas(), indiceSelecionado);
}
}
/*
* deve ser flush e straight e ter certas cartas
*/
private static bool EhRoyalFlush(Mao h)
{
if (EhStraight(h) && EhFlush(h) &&
h[0].Rank == Rank.As &&
h[1].Rank == Rank.Dez &&
h[2].Rank == Rank.Valete &&
h[3].Rank == Rank.Dama &&
h[4].Rank == Rank.Rei)
{
return(true);
}
return(false);
}
IEnumerator DarDano(GameObject obj, GameObject atacante)
{
//animações dos efeitos
Mao player = transform.GetComponent <Mao>();
yield return(new WaitForSeconds(0.4f));
if (obj && obj.transform.GetChild(0))
{
obj.transform.GetChild(0).GetComponent <CartaNaMesa>().Defesa -= atacante.transform.GetChild(0).GetComponent <CartaNaMesa>().Ataque;
atacante.transform.GetChild(0).GetComponent <CartaNaMesa>().Defesa -= obj.transform.GetChild(0).GetComponent <CartaNaMesa>().Ataque;
}
player.Audio(2);
}
public bool Tem_Dois_Pares(Mao mao1)
{
var cartas = mao1.Cartas;
var listaDePares = new Dictionary<Carta, Carta>();
for (int index = 0; index < cartas.Count; index++)
{
for (int i = index + 1; i < cartas.Count; i++)
{
if (cartas[index].Numero == cartas[i].Numero)
{
listaDePares.Add(cartas[index], cartas[i]);
}
}
}
return listaDePares.Count == 2;
}
/*
* ou uma trinca e um par
* ou um par e uma trinca
*/
private static bool EhFullHouse(Mao h)
{
// par e trinca
if (h[0].Rank == h[1].Rank &&
h[2].Rank == h[3].Rank &&
h[3].Rank == h[4].Rank)
{
return(true);
}
// trinca e par
if (h[0].Rank == h[1].Rank &&
h[1].Rank == h[2].Rank &&
h[3].Rank == h[4].Rank)
{
return(true);
}
return(false);
}
/*
* ou as quatro primeiras tem o mesmo rank
* ou as quatro últimas tem o mesmo rank
*/
private static bool EhQuadra(Mao h)
{
// quatro primeiras
if (h[0].Rank == h[1].Rank &&
h[1].Rank == h[2].Rank &&
h[2].Rank == h[3].Rank)
{
return(true);
}
// quatro últimas
if (h[1].Rank == h[2].Rank &&
h[2].Rank == h[3].Rank &&
h[3].Rank == h[4].Rank)
{
return(true);
}
return(false);
}
public void DeveGerarMao()
{
var cartas = new List <Carta>
{
_primeiraCarta,
_segundaCarta
};
var maoEsperada = new
{
Cartas = cartas,
Classificacao = "",
Pontuacao = Int64.Parse("0")
};
var maoGerada = new Mao(_primeiraCarta, _segundaCarta);
maoEsperada.ToExpectedObject().ShouldMatch(maoGerada);
}
public void evaluateMaos()
{
AvaliadorDaMao mao1Avaliador = new AvaliadorDaMao(cartasNaMao1);
AvaliadorDaMao mao2Avaliador = new AvaliadorDaMao(cartasNaMao2);
Mao mao1 = mao1Avaliador.AvalieMao();
Mao mao2 = mao2Avaliador.AvalieMao();
Console.WriteLine("\n\n\n\n\nJogador 1: " + mao1);
Console.WriteLine("\nJogador 2: " + mao2);
if (mao1 > mao2)
{
Console.WriteLine("Jogador 1 venceu! ┏(;))┛");
}
else if (mao1 < mao2)
{
Console.WriteLine("Jogador 2 venceu! ┏( ͡;))┛");
}
else
{
if (mao1Avaliador.ValoresDaMao.Total > mao2Avaliador.ValoresDaMao.Total)
{
Console.WriteLine("Jogador 1 venceu! ┏( ͡;))┛");
}
else if (mao1Avaliador.ValoresDaMao.Total < mao2Avaliador.ValoresDaMao.Total)
{
Console.WriteLine("Jogador 2 venceu! ┏( ͡;) )┛");
}
else if (mao1Avaliador.ValoresDaMao.MaiorCarta > mao2Avaliador.ValoresDaMao.MaiorCarta)
{
Console.WriteLine("Jogador 1 venceu! ┏( ͡;))┛");
}
else if (mao1Avaliador.ValoresDaMao.MaiorCarta < mao2Avaliador.ValoresDaMao.MaiorCarta)
{
Console.WriteLine("Jogador 2 venceu! ┏( ͡;))┛");
}
else
{
Console.WriteLine("Ninguém ganhou");
}
}
}
public bool Eh_Um_Par(Mao mao1)
{
var cartas = mao1.Cartas;
Carta primeira = cartas.First();
bool tempar = false;
for (int index = 0; index < cartas.Count; index++)
{
for (int i = index + 1; i < cartas.Count; i++)
{
if (cartas[index].Numero == cartas[i].Numero)
{
tempar = true;
break;
}
}
}
return tempar;
}
/*
* confere que o rank difere em 1
* isso é possível porque assumimos
* que está ordernado
*/
private static bool EhStraight(Mao h)
{
if (h[0].Rank == h[1].Rank - 1 &&
h[1].Rank == h[2].Rank - 1 &&
h[2].Rank == h[3].Rank - 1 &&
h[3].Rank == h[4].Rank - 1)
{
return(true);
}
// caso special porque Az é menor que dez
if (h[1].Rank == Rank.Dez &&
h[2].Rank == Rank.Valete &&
h[3].Rank == Rank.Dama &&
h[4].Rank == Rank.Rei &&
h[0].Rank == Rank.As)
{
return(true);
}
return(false);
}
/*
* ou a 1a carta igual a 2a carta
* ou a 2a carta igual a 3a carta
* ou a 3a carta igual a 4a carta
* ou a 4a carta igual a 5a carta
*/
private static bool EhPar(Mao h)
{
if (h[0].Rank == h[1].Rank)
{
return(true);
}
if (h[1].Rank == h[2].Rank)
{
return(true);
}
if (h[2].Rank == h[3].Rank)
{
return(true);
}
if (h[3].Rank == h[4].Rank)
{
return(true);
}
return(false);
}
/*
* assume:
* -> a mão deve estar ordenada
* -> as cartas não podem repetir
*/
public static Combinacao CalculaScore(Mao h)
{
if (EhRoyalFlush(h))
{
return Combinacao.RoyalFlush;
}
if (EhStraightFlush(h))
{
return Combinacao.StraightFlush;
}
if (EhQuadra(h))
{
return Combinacao.Quadra;
}
if (EhFullHouse(h))
{
return Combinacao.FullHouse;
}
if (EhFlush(h))
{
return Combinacao.Flush;
}
if (EhStraight(h))
{
return Combinacao.Straight;
}
if (EhTrinca(h))
{
return Combinacao.Trinca;
}
if (EhDoisPares(h))
{
return Combinacao.DoisPares;
}
if (EhPar(h))
{
return Combinacao.Par;
}
return Combinacao.Nenhuma;
}
/*
* assume:
* -> a mão deve estar ordenada
* -> as cartas não podem repetir
*/
public static Combinacao CalculaScore(Mao h)
{
if (EhRoyalFlush(h))
{
return(Combinacao.RoyalFlush);
}
if (EhStraightFlush(h))
{
return(Combinacao.StraightFlush);
}
if (EhQuadra(h))
{
return(Combinacao.Quadra);
}
if (EhFullHouse(h))
{
return(Combinacao.FullHouse);
}
if (EhFlush(h))
{
return(Combinacao.Flush);
}
if (EhStraight(h))
{
return(Combinacao.Straight);
}
if (EhTrinca(h))
{
return(Combinacao.Trinca);
}
if (EhDoisPares(h))
{
return(Combinacao.DoisPares);
}
if (EhPar(h))
{
return(Combinacao.Par);
}
return(Combinacao.Nenhuma);
}
/*
* ou as três primeiras tem mesmo rank
* ou as três do meio tem mesmo rank
* ou as três últimas tem mesmo rank
*/
private static bool EhTrinca(Mao h)
{
// três primeiras
if (h[0].Rank == h[1].Rank &&
h[1].Rank == h[2].Rank)
{
return(true);
}
// três do meio
if (h[1].Rank == h[2].Rank &&
h[2].Rank == h[3].Rank)
{
return(true);
}
// três últimas
if (h[2].Rank == h[3].Rank &&
h[3].Rank == h[4].Rank)
{
return(true);
}
return(false);
}
/*
* ou dois pares no início
* ou dois pares separados pela carta do meio
* ou dois pares no final
*/
private static bool EhDoisPares(Mao h)
{
// dois pares no início
if (h[0].Rank == h[1].Rank &&
h[2].Rank == h[3].Rank)
{
return(true);
}
// dois pares separados pela carta do meio
if (h[0].Rank == h[1].Rank &&
h[3].Rank == h[4].Rank)
{
return(true);
}
// dois pares no final
if (h[1].Rank == h[2].Rank &&
h[3].Rank == h[4].Rank)
{
return(true);
}
return(false);
}
/*
* ou dois pares no início
* ou dois pares separados pela carta do meio
* ou dois pares no final
*/
private static bool EhDoisPares(Mao h)
{
// dois pares no início
if (h[0].Rank == h[1].Rank &&
h[2].Rank == h[3].Rank)
{
return true;
}
// dois pares separados pela carta do meio
if (h[0].Rank == h[1].Rank &&
h[3].Rank == h[4].Rank)
{
return true;
}
// dois pares no final
if (h[1].Rank == h[2].Rank &&
h[3].Rank == h[4].Rank)
{
return true;
}
return false;
}
void ReciboMulliganClientRpc(int rn, int rn2)
{
var mullig = GameObject.Find("MulliganBackground");
mullig.GetComponent <Animator>().SetTrigger("Event");
Mao player = GameObject.Find("Canvas").GetComponent <Mao>();
PlayerAdversario player2 = GameObject.Find("Canvas").GetComponent <PlayerAdversario>();
if (!IsOwner)
{
mullig.GetComponent <MulliganBehaviour>().CriarCarta(rn);
player.CriarCartaInicio(rn);
player2.CriarCarta(rn2);
}
else
{
mullig.GetComponent <MulliganBehaviour>().CriarCarta(rn2);
player.CriarCartaInicio(rn2);
player2.CriarCarta(rn);
}
GameObject.Find("Canvas").GetComponent <EventControllerBehaviour>().BotaoInteragivel(IsOwner);
}
public void OnMulliganClick()
{
transform.GetChild(0).GetComponent <Selectable>().interactable = false;
//ntwrkid = NetworkClient.connection.identity;
//playerid = ntwrkid.GetComponent<PlayerId>();
Mao player = canvas.GetComponent <Mao>();
int rejeitados = 0;
for (int i = 0; i != cartas.Count; i++)
{
SetAnimacao(40);
print(i);
if (cartas[i].transform.childCount != 1)
{
cartas[i].GetComponent <Animator>().SetBool("Destruir", true);
player.DestruirCartaBaralho(player.mao[i]);
player.distanciamentoCartasMaximo -= 20;
player.mao.RemoveAt(i);
canvas.GetComponent <EventControllerBehaviour>().PlayerAtual.TirarCartaBaralhoInimigoServerRpc(i);
cartas.RemoveAt(i);
SetAnimacao(40);
player.SetAnimacaoInicial(player.distanciamentoCartasMaximo);
rejeitados++;
i--;
// playerid
}
while (rejeitados != 0)
{
int rnd = Random.Range(0, canvas.GetComponent <EventControllerBehaviour>().numeroCartas);
canvas.GetComponent <EventControllerBehaviour>().PlayerAtual.AdicionarAoBaralhoServerRpc(rnd);
CriarCarta(rnd);
SetAnimacao(40);
rejeitados--;
}
final = true;
}
}
private void Start()
{
testandoNoEditor = false;
DefinirPlayerIdJogadores();
PlayerHost.PedidoMulliganHost();
//botao.transform.GetChild(0).GetComponent<Text>().text = "INICIAR";
turno = Turnos.DecidirIniciante;
Inimigo = GetComponent <PlayerAdversario>();
Player = GetComponent <Mao>();
ouroLimite = 10;
ouroMaximo = 1;
Player.SetarGold(ouroMaximo);
Inimigo.SetarGold(ouroMaximo);
CartasInimigo = transform.GetChild(2).GetComponent <MesaBehaviour>();
CartasPlayer = transform.GetChild(1).GetComponent <MesaBehaviour>();
preparado = true;
}
private void OnMaoReleaseUp(Mao mao)
{
UILogic.Instance.Confertable.SetHeadIcon(HeadState.Normal);
}
/*
* deve ser flush e straight e ter certas cartas
*/
private static bool EhRoyalFlush(Mao h)
{
if (EhStraight(h) && EhFlush(h) &&
h[0].Rank == Rank.As &&
h[1].Rank == Rank.Dez &&
h[2].Rank == Rank.Valete &&
h[3].Rank == Rank.Dama &&
h[4].Rank == Rank.Rei)
{
return true;
}
return false;
}
/*
* todas as cartas são do mesmo naipe
*/
private static bool EhFlush(Mao h)
{
if (h[0].Naipe == h[1].Naipe &&
h[1].Naipe == h[2].Naipe &&
h[2].Naipe == h[3].Naipe &&
h[3].Naipe == h[4].Naipe)
{
return true;
}
return false;
}
private void OnMaoTouchDown(Mao mao)
{
UILogic.Instance.Confertable.SetHeadIcon(HeadState.Nervious);
}
/*
* ou a 1a carta igual a 2a carta
* ou a 2a carta igual a 3a carta
* ou a 3a carta igual a 4a carta
* ou a 4a carta igual a 5a carta
*/
private static bool EhPar(Mao h)
{
if (h[0].Rank == h[1].Rank)
{
return true;
}
if (h[1].Rank == h[2].Rank)
{
return true;
}
if (h[2].Rank == h[3].Rank)
{
return true;
}
if (h[3].Rank == h[4].Rank)
{
return true;
}
return false;
}
/*
* ou uma trinca e um par
* ou um par e uma trinca
*/
private static bool EhFullHouse(Mao h)
{
// par e trinca
if (h[0].Rank == h[1].Rank &&
h[2].Rank == h[3].Rank &&
h[3].Rank == h[4].Rank)
{
return true;
}
// trinca e par
if (h[0].Rank == h[1].Rank &&
h[1].Rank == h[2].Rank &&
h[3].Rank == h[4].Rank)
{
return true;
}
return false;
}
/*
* ou as quatro primeiras tem o mesmo rank
* ou as quatro últimas tem o mesmo rank
*/
private static bool EhQuadra(Mao h)
{
// quatro primeiras
if (h[0].Rank == h[1].Rank &&
h[1].Rank == h[2].Rank &&
h[2].Rank == h[3].Rank)
{
return true;
}
// quatro últimas
if (h[1].Rank == h[2].Rank &&
h[2].Rank == h[3].Rank &&
h[3].Rank == h[4].Rank)
{
return true;
}
return false;
}
/*
* é straight e flush
*/
private static bool EhStraightFlush(Mao h)
{
if (EhStraight(h) && EhFlush(h))
{
return true;
}
return false;
}
/*
* ou as três primeiras tem mesmo rank
* ou as três do meio tem mesmo rank
* ou as três últimas tem mesmo rank
*/
private static bool EhTrinca(Mao h)
{
// três primeiras
if (h[0].Rank == h[1].Rank &&
h[1].Rank == h[2].Rank)
{
return true;
}
// três do meio
if (h[1].Rank == h[2].Rank &&
h[2].Rank == h[3].Rank)
{
return true;
}
// três últimas
if (h[2].Rank == h[3].Rank &&
h[3].Rank == h[4].Rank)
{
return true;
}
return false;
}
public AvaliadorDeJogo(Mao mao2, Mao mao1)
{
Mao1 = mao1;
Mao2 = mao2;
}
public bool Tem_Uma_Trinca(Mao mao1)
{
var cartas = mao1.Cartas;
var listaTrinca = new List<Carta>();
var listaResto = new List<Carta>();
for (int index = 0; index < cartas.Count; index++)
{
for (int i = index + 1; i < cartas.Count; i++)
{
for (int j = i + 1; j < cartas.Count; j++)
{
if (cartas[index].Numero == cartas[i].Numero && cartas[i].Numero == cartas[j].Numero)
{
listaTrinca.Add(cartas[index]);
break;
}
}
}
}
listaResto = cartas.Where(x => x.Numero != listaTrinca.First().Numero).ToList();
return listaTrinca.Count == 1 && listaResto.Count == 2;
}
private void OnEnable()
{
mao = target as Mao;
}
/*
* confere que o rank difere em 1
* isso é possível porque assumimos
* que está ordernado
*/
private static bool EhStraight(Mao h)
{
if (h[0].Rank == h[1].Rank - 1 &&
h[1].Rank == h[2].Rank - 1 &&
h[2].Rank == h[3].Rank - 1 &&
h[3].Rank == h[4].Rank - 1)
{
return true;
}
// caso special porque Az é menor que dez
if (h[1].Rank == Rank.Dez &&
h[2].Rank == Rank.Valete &&
h[3].Rank == Rank.Dama &&
h[4].Rank == Rank.Rei &&
h[0].Rank == Rank.As)
{
return true;
}
return false;
}
