Poker

INTRODUÇÃO

Este trabalho tem como objetivo desenvolver algoritmos capazes de avaliar um conjunto de 7 cartas no contexto do poker. A proposta consiste em analisar essas cartas e identificar padrões específicos por meio de verificações lógicas.

Para isso, a solução foi organizada em algoritmos independentes, onde cada um é responsável por reconhecer uma condição dentro do conjunto de cartas. Dessa forma, o trabalho busca aplicar conceitos de lógica e organização na construção de soluções para o problema proposto.

---------

M3

Na etapa anterior, o trabalho avaliava conjuntos isolados de 7 cartas a partir de arquivos CSV. Nesta etapa, o objetivo passou a ser simular uma rodada simplificada de uma partida de poker: criar um baralho completo, embaralhar, distribuir cartas para dois jogadores e para a mesa, avaliar a melhor mão de cada jogador e indicar o vencedor, incluindo o desempate por carta mais alta quando necessário.

O projeto ainda não implementa um jogo completo de poker — não há apostas, fichas ou múltiplas rodadas. O foco continua sendo lógica, organização e, agora, também tomada de decisão.

---------------------------------------------------------------

ESTRUTURA DE DADOS

Durante o desenvolvimento do projeto, foram aplicados conceitos fundamentais da disciplina de Estruturas de Dados, como dados, informação, estruturas de dados, tipos abstratos de dados e organização lógica.

As cartas foram tratadas como dados estruturados, contendo atributos como valor, naipe e origem (location).  A partir desses dados, geramos informação ao identificar padrões do jogo, como as sequências de pares, trincas, quadras, etc. Para organizar e manipular esses dados, utilizamos uma estrutura de dados do tipo array de listas (histograma), onde cada posição representa um valor de carta e armazena todas as suas ocorrências.



Essa estrutura pode ser entendida como um tipo abstrato de dados, pois define uma forma específica de armazenar e acessar as cartas, permitindo operações eficientes de busca e contagem.

---------------------------------------------------------------

ALGORITMOS E PROJETO BASE

Projeto desenvolvido em C# com arquitetura em camadas (domain, application, infrastructure e presentation) para reconhecimento de mãos de Poker Texas Hold’em.

A estrutura principal utiliza um histograma de cartas (CardHistogram), organizando as cartas por valor em um array de listas, permitindo acesso direto às combinações sem percorrer toda a mão repetidamente.

O sistema utiliza:

• List<Card> para armazenamento das cartas;
• Dictionary para mapeamentos e reconhecedores;
• Enums (Suit, CardLocation, HandRank) para evitar strings soltas;
• Herança e polimorfismo através da classe abstrata Rank.

---------

M3

A arquitetura em camadas foi mantida sem alterações estruturais. As classes Card, CardHistogram, os enums e os nove algoritmos de reconhecimento continuam os mesmos da etapa anterior.

Foram adicionadas seis novas classes:

Deck, responsável por criar e embaralhar o baralho de 52 cartas;

Player, responsável por armazenar as cartas de cada jogador;

TableCards, responsável pelas cartas comunitárias da mesa;

HandEvaluator, responsável por avaliar a melhor mão de cada jogador;

WinnerResolver, responsável por comparar os jogadores e decidir o vencedor;

GameSimulator, responsável por orquestrar a rodada do início ao fim.

O enum HandRank recebeu o valor CartaAlta, necessário para tratar a carta mais alta como uma mão válida.

---------------------------------------------------------------

DESENVOLVIMENTO 

Foram implementados 9 algoritmos de reconhecimento de mãos:

Par

Dois Pares

Trinca

Straight

Flush

Full House

Quadra

Straight Flush

Royal Flush

Cada algoritmo funciona de forma independente, herdando de Rank e sobrescrevendo o método reconhecer_mao.

O projeto respeita a regra de participação do jogador: mãos formadas apenas pelas cartas da mesa não são consideradas válidas.

Destaques:

• Tratamento correto do Ás em sequências baixas (A-2-3-4-5) e altas (10-J-Q-K-A);
• Straight Flush validado simultaneamente por sequência e naipe;
• Full House cobrindo também casos com duas trincas.

---------------------------------------------------------------

TESTES

O sistema possui 27 testes automatizados em arquivos CSV:

• Casos positivos;
• Casos negativos;
• Casos específicos.

Cada teste simula uma rodada completa de Texas Hold’em com:

• 2 cartas do jogador;
• 5 cartas da mesa.
• O programa permite:
• Testar um caso específico;

Executar todos os testes automaticamente.

• Resultado esperado:
• 27 aprovados
• 0 reprovados

---------------------------------------------------------------

SIMULAÇÃO DA RODADA

O baralho é criado combinando os 4 naipes com os 13 valores, gerando 52 cartas únicas. O embaralhamento usa o algoritmo de Fisher-Yates, garantindo que nenhuma carta seja perdida ou duplicada.

A distribuição segue a ordem: primeira carta para o Jogador 1, primeira carta para o Jogador 2, segunda carta para cada um, e por fim 5 cartas para a mesa.

Cada jogador é avaliado separadamente, combinando suas 2 cartas com as 5 da mesa — 7 cartas no total —, reaproveitando diretamente os reconhecedores já implementados. As cartas dos dois jogadores nunca são misturadas no mesmo histograma.

---------------------------------------------------------------

CONSIDERAÇÕES FINAIS

Este projeto mostrou como lógica e organização fazem diferença em problemas aparentemente simples. O Poker possui várias exceções e detalhes que facilmente geram erros, então desenvolver os algoritmos exigiu atenção constante aos casos específicos e à eficiência das verificações.

A estrutura baseada em histograma deixou o sistema mais bem mais rápido, enquanto o uso de herança e polimorfismo ajudou a transformar cada mão em um reconhecedor independente, deixando o código mais limpo e escalável.

Mais do que reconhecer cartas, o projeto serviu para exercitar pensamento lógico, arquitetura de software e resolução de problemas de forma prática, aproximando a teoria de um sistema real funcionando de verdade.

Comentários:

Apesar dos pesares, acho que foi um trabalho bem interessante, sinto que realmente entendi como funciona um código na prática, tive bastante dificuldade, mas no final deu tudo certo.  - LoneMage

Como alguém que já jogou poker previamente. Trabalhar com poker e programação ao mesmo tempo foi uma experiência inusitada. - CantBelieveItsEdward

---------------------------------------------------------------

REFERÊNCIAS

As seguintes referências foram utilizadas como apoio para o desenvolvimento do trabalho:

WIKIPEDIA. Standard 52 card - https://en.wikipedia.org/wiki/Standard_52-card_deck
-> Utilizado para entender a estrutura do baralho e os valores das cartas.

WIKIPEDIA. Texas Hold -  https://en.wikipedia.org/wiki/Texas_hold_%27em
-> Utilizado para compreender o funcionamento do jogo e o uso das 7 cartas.

WIKIPEDIA. List of poker hands - https://en.wikipedia.org/wiki/List_of_poker_hands
-> Utilizado para entender e validar as diferentes combinações de mãos do poker.

POKERSTARS.  Hand Rackings - https://www.pokerstars.com/pt-BR/poker/games/rules/hand-rankings/?&no_redirect=1
-> Utilizado como apoio para confirmar a hierarquia das mãos e suas regras.

LEARN MICROSOFT.  C# Array - https://learn.microsoft.com/pt-br/dotnet/csharp/language-reference/builtin-types...
-> Utilizado como apoio para confirmar o funcionamento do array como um todo.

LEARN MICROSOFT.  C# List\ - https://learn.microsoft.com/pt-br/dotnet/api/system.collections.generic.list-1
-> Utilizado como apoio para confirmar o funcionamento das listas.

LEARN MICROSOFT.  C# Dictionary\ - https://learn.microsoft.com/pt-br/dotnet/api/system.collections.generic.dictiona...
-> Utilizado como apoio para confirmar o funcionamento do dictionary.

LEARN MICROSOFT.  C# Random.Next - https://learn.microsoft.com/pt-br/dotnet/api/system.random.next
-> Utilizado como apoio para confirmar o funcionamento do embaralhamento aleatório.

---------------------------------------------------------------

EQUIPE

Eduardo May da Silva - Slide, Programação - CantBelieveItsEdward

Eros Andrade Lima - Programação, Itchio - LoneMage

---------------------------------------------------------------

Universidade do Vale do Itajaí - UNIVALI

Maurício de Campos | Diretor Escola Politécnica

Giorgio Gilwan | Coordenador do Curso de Design de Games

Rafael Kojiio | Coordenador Gamelab UNIVALI

---------------------------------------------------------------

* Projeto  desenvolvido como requisito parcial para obtenção de aprovação na disciplina de Fundamentos de Programação para Games (professor: m4rc3lo), curso de Design de Games.

** O conteúdo aqui tem direito reservado e pode conter inconsistências conceituais.