Projeto em C#: Reconhecimento de Mãos de Poker com Estruturas de Dados

Introdução

Nesta disciplina, buscamos aprender técnicas para representar, organizar e manipular dados de forma eficiente, utilizando conceitos fundamentais de programação e estruturas de dados aplicadas a problemas práticos.

A metodologia adotada é a aprendizagem baseada em projetos, que promove a construção do conhecimento por meio de desafios reais e colaborativos, estimulando o pensamento crítico e a autonomia dos estudantes.

O projeto desenvolvido ao longo da disciplina tem como tema o reconhecimento de mãos de pôquer, especificamente no estilo Texas Hold’em, abordando tanto aspectos lógicos quanto estruturais da programação voltada para jogos.

O problema central consiste em identificar corretamente a melhor mão de pôquer entre dois jogadores, considerando as cinco cartas da mesa e as duas cartas de cada jogador, determinando o vencedor ou declarando empate.

Nesta etapa final, nossos objetivos específicos foram: revisar e corrigir o código da M2, implementar a simulação completa de uma rodada de pôquer entre dois jogadores, criar a lógica de comparação das mãos e integrar todos os componentes em uma estrutura funcional e clara.

Essa fase é muito importante para a nossa formação em Design de Games, pois nos permite vivenciar o ciclo completo de um projeto técnico, da teoria à execução final, com foco em boas práticas, testes e simulação de um sistema real.

O projeto seguiu uma sequência lógica: ajustes com base no feedback da M2, planejamento da estratégia de simulação, implementação da comparação de mãos, testes com diversos cenários e documentação da versão final.

A avaliação da M3 considera principalmente a qualidade da simulação de jogo, a clareza da estratégia de implementação adotada e a correção geral do código, exigindo que as equipes demonstrem maturidade no desenvolvimento.

Esperamos, com essa etapa, consolidar nosso domínio sobre lógica de programação, uso de classes, herança, enums e manipulação de dados em C#, além de aprimorar a capacidade de trabalhar em equipe e resolver problemas complexos.

Nos próximos capítulos, o relatório irá detalhar a estratégia adotada para a etapa final e como organizamos nosso projeto.

Desenvolvimento

Durante a etapa final do projeto, nossa principal estratégia foi transformar o código anterior, que lia cartas de arquivos CSV, em um sistema totalmente automatizado de geração e distribuição de cartas para simular uma partida real de poker entre dois jogadores. Para isso, ajustamos o script Load para que ele embaralhasse um baralho padrão de 52 cartas e distribuísse aleatoriamente duas cartas para cada jogador e cinco para a mesa.

No Program.cs, organizamos o fluxo da simulação para seguir as etapas de uma partida de Texas Hold’em: pré-flop (apenas cartas dos jogadores), flop (3 cartas na mesa), turn (4 cartas) e river (as 5 cartas finais). Em cada etapa, as cartas são reveladas aos poucos no console, criando uma sensação mais próxima de uma partida real.

A lógica de comparação entre os jogadores foi baseada na junção das cartas individuais de cada jogador com as da mesa. Cada conjunto de 7 cartas era então avaliado por uma função que retorna um ranking numérico para a melhor mão possível. Quanto menor esse número, melhor a mão — por exemplo, Royal Flush vale 1, Straight Flush vale 2, e assim por diante até Carta Alta com valor 10.

O sistema então compara os rankings dos dois jogadores para determinar quem venceu. Em caso de empate, o programa avalia quem tem a carta mais alta. Essa abordagem foi eficiente, simples de entender e suficiente para cobrir todos os casos exigidos no projeto.

Além da lógica de jogo, também fizemos as correções indicadas pelo professor na etapa M2. Nosso código anterior já estava praticamente completo, mas pequenos ajustes de clareza, organização e padronização foram aplicados para garantir uma versão final mais robusta.

A estratégia adotada se concentrou em manter o código modular, reutilizável e fácil de testar. Usamos herança e polimorfismo nas classes das mãos (como Royal, Flush, Trinca etc.), e mantivemos o controle de exibição e comparação bem separado da lógica de avaliação.

Esse processo nos ajudou a consolidar o uso de boas práticas de orientação a objetos e reforçou a importância de manter o código limpo e bem comentado. A implementação prática de toda a lógica, da simulação até a decisão final do vencedor, foi o ponto alto da nossa experiência no projeto.

Considerações Finais

Gianluca: Como responsável pela programação dos algoritmos, foi interessante adaptar scripts existentes para atender a um novo objetivo. Com mais experiência, esse processo de adaptação se tornou consideravelmente mais fácil.

Juan Pedro: Nesta etapa final do projeto, fui incumbido de aprimorar e expandir os conceitos apresentados nas definições M2 do documento, após o feedback recebido no período anterior sobre a falta de informações mais específicas e detalhadas sobre os conceitos apresentados. Não foi um processo excessivamente complexo, pois as ideias em si já estavam mais claras; bastava uma análise mais aprofundada.

Vitor Luna: Nesta última etapa do projeto, contribuí principalmente com a organização e montagem da apresentação final, garantindo que o conteúdo estivesse claro e bem estruturado. Além disso, também auxiliei a equipe na definição da estratégia de implementação do código, participando das decisões sobre como a simulação do jogo seria estruturada e executada. 

Maria Clara: Fiquei responsável pela organização da página do projeto no Itch.io e pela documentação final, garantindo que tudo estivesse bem apresentado e completo. Apesar de ter focado mais nessas partes, consegui entender muito bem a parte teórica da matéria ao longo do projeto, principalmente agora na etapa final, onde tudo fez mais sentido com a aplicação prática.

Referências

Livros:

Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford. Introduction to Algorithms [recurso eletrônico]. 4. ed. Cambridge: MIT Press, 2022. ISBN 978-0-262-04630-5. Disponível em: https://pt.wikipedia.org/wiki/Introdu%C3%A7%C3%A3o_aos_Algoritmos. Acesso em: 30 Mar. 2025.

Szwarcfiter, Jayme L.; Markenzon, Lilian. Estruturas de Dados e Seus Algoritmos [recurso eletrônico]. 3. ed. Rio de Janeiro: LTC, 2020. ISBN 978-85-216-2691-2.

Sites:

Data Structures Tutorial. Site: [https://www.geeksforgeeks.org/data-structures/]. Acesso em 15 de Maio de 2025

Connect, code, and grow. Object-Oriented programming (C#). Site: [https://learn.microsoft.com/en-us/dotnet/csharp/fundamentals/tutorials/oop]. Acesso em 15 de Maio de 2025

C# Tutorial. Site: [https://www.tutorialspoint.com/csharp/index.htm]. Acesso em 15 de Maio de 2025

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

Equipe

Gianluca Daunis Zanetti - gianlucazt.itch.io

Juan Pedro Silveira Ayres - pedro-univali.itch.io

Maria Clara Pontel Volpato - claravolpato.itch.io

Vitor Battistella Luna -  vituluna.itch.io

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

Projeto desenvolvido como requisito parcial para obtenção de aprovação na disciplina:  Estruturas de Dados - professor m4rc3lo

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

conceituais. 

Universidade do Vale do Itajaí - UNIVALI 

Cesar Albenes Zeferino | Diretor Escola Politécnica  

Giorgio Gilwan | Coordenador do Curso: Design de Games

Rafael Kojiio | Coordenador Gamelab