Subprogramas de leitura de mãos de poker escritas em histograma

Introdução

  ¹ O objetivo geral da disciplina é ensinar técnicas para organizar, processar e interpretar dados por meio de algoritmos e estruturas de dados eficientes, promovendo a construção de soluções computacionais estruturadas e reutilizáveis. A disciplina também busca desenvolver a capacidade de análise lógica, modelagem de problemas e implementação de algoritmos em linguagem de programação orientada a objetos.

 ² A disciplina adota a metodologia de aprendizagem baseada em projetos (ABP), que propõe o desenvolvimento do conhecimento a partir da resolução de desafios práticos e contextualizados. Essa abordagem estimula o aluno a assumir um papel ativo na construção do seu próprio aprendizado, promovendo o desenvolvimento de competências técnicas e analíticas, além de habilidades como trabalho em equipe, tomada de decisão e organização.

 ³ Neste projeto, foi proposto o desenvolvimento de um sistema capaz de identificar automaticamente as diferentes mãos do jogo de poker, mais especificamente da modalidade Texas Hold’em, utilizando técnicas de programação orientada a objetos e estruturas de dados. O sistema deve ser capaz de analisar combinações entre cartas comunitárias e individuais dos jogadores para reconhecer se há uma mão válida e qual é seu tipo.

 ⁴ O principal desafio do projeto está em como identificar, de forma precisa e eficiente, combinações específicas de cartas entre um conjunto de sete disponíveis. O sistema precisa considerar apenas combinações que envolvam pelo menos uma carta do jogador, tornando o processo de verificação mais complexo. O objetivo principal é criar um algoritmo robusto que execute esse reconhecimento respeitando as regras do poker.

 ⁵ Os objetivos específicos incluem: implementar 10 classes especializadas para reconhecer cada tipo de mão de poker (como Sequência Real e Flush) usando herança e polimorfismo; desenvolver arquivos CSV de teste para validar as combinações; garantir precisão nos algoritmos de detecção; e documentar claramente o código e a lógica utilizada.

 ⁶ O projeto promove o desenvolvimento de competências em programação, análise algorítmica e modelagem de dados, além de incentivar a aplicação prática dos conceitos teóricos da disciplina.

 ⁷ O projeto foi desenvolvido em três etapas: análise do problema, criação das classes e algoritmos, e testes com arquivos CSV, envolvendo leitura de dados e uso de orientação a objetos.

 ⁸ A avaliação do projeto considerou a corretude dos algoritmos (peso 6) e a qualidade da documentação (peso 4), além de critérios como clareza, comentários no código e aderência à estrutura proposta.

 ⁹  Ao final do projeto, os estudantes devem entender melhor estruturas de dados, leitura de arquivos, reconhecimento de padrões e organização de sistemas usando a arquitetura MVC.

 ¹⁰ O documento está dividido em quatro capítulos: Introdução, Fundamentação Teórica, Desenvolvimento e Considerações Finais, abordando desde os conceitos utilizados até a implementação e reflexões sobre o aprendizado.

Fundamentação Teórica

Dados são elementos brutos, como números, textos ou símbolos, que por si só não possuem significado. Informações, por outro lado, são dados processados e interpretados dentro de um contexto, adquirindo relevância e utilidade. Por exemplo, "100" é apenas um dado; ao contextualizá-lo como "100 pontos de vida de um personagem", torna-se uma informação significativa no universo dos jogos digitais.

Nos jogos digitais, dados representam os elementos fundamentais, como posições de personagens, pontuações e estados de objetos. Esses dados, quando processados pelo sistema do jogo, transformam-se em informações que determinam comportamentos, como a movimentação de um inimigo ou a ativação de uma habilidade. Assim, a correta interpretação e manipulação de dados são essenciais para a dinâmica e interatividade dos jogos.

2.1 Tipos de Dados

Tipos de dados homogêneos são aqueles que armazenam elementos do mesmo tipo. Um exemplo clássico é o array ou vetor, que pode conter uma sequência de números inteiros representando, por exemplo, os pontos de vida de diferentes personagens em um jogo. Essa uniformidade facilita operações como iteração e cálculo de estatísticas.

Tipos de dados heterogêneos permitem armazenar elementos de diferentes tipos em uma única estrutura. Um exemplo é uma estrutura que combina um número inteiro (pontuação), uma string (nome do jogador) e um booleano (status de ativo), representando um jogador em um jogo. Essas estruturas são úteis para agrupar informações relacionadas de diferentes naturezas.

Tipos Abstratos de Dados (TADs) são modelos que definem um conjunto de operações aplicáveis a certos dados, independentemente de sua implementação. Eles encapsulam dados e as operações permitidas sobre eles, promovendo modularidade e reutilização de código. Exemplos comuns de TADs incluem listas, pilhas e filas, que são amplamente utilizados na programação de jogos para gerenciar sequências de ações, históricos de eventos e gerenciamento de tarefas.

2.2 Estruturas de Dados

Arranjos unidimensionais, ou vetores, são estruturas que armazenam elementos em uma única linha. Eles são úteis para representar sequências simples, como a lista de pontuações de jogadores ou os níveis de dificuldade disponíveis em um jogo. Sua simplicidade permite acesso rápido e eficiente aos elementos.

Arranjos multidimensionais, como matrizes, armazenam dados em múltiplas dimensões. Em jogos, são frequentemente utilizados para representar mapas, tabuleiros ou grades, onde cada elemento pode indicar a presença de um objeto, terreno ou personagem. Essa estrutura facilita a navegação e manipulação de ambientes bidimensionais ou tridimensionais.

Pilhas, filas e listas são estruturas de dados fundamentais na programação. Pilhas operam no modelo LIFO (último a entrar, primeiro a sair) e são úteis para gerenciar ações reversíveis, como desfazer movimentos. Filas seguem o modelo FIFO (primeiro a entrar, primeiro a sair), sendo ideais para gerenciar eventos em ordem cronológica, como ações de inimigos. Listas permitem inserções e remoções em posições específicas, sendo versáteis para gerenciar inventários ou listas de missões.

2.3 Orientação a Objetos

A Programação Orientada a Objetos (POO) é um paradigma que organiza o software em torno de objetos, que são instâncias de classes. Classes definem atributos (dados) e métodos (comportamentos) que seus objetos possuirão. Os princípios fundamentais da POO incluem encapsulamento (ocultação de detalhes internos), herança (reutilização de código através de hierarquias) e polimorfismo (capacidade de objetos responderem de maneira diferente a mesma operação).

No desenvolvimento de jogos, a POO permite modelar entidades do jogo, como personagens, inimigos e itens, como objetos com atributos e comportamentos específicos. Isso facilita a organização do código, a reutilização de componentes e a manutenção do software. Por exemplo, uma classe "Inimigo" pode ser a base para diferentes tipos de inimigos, cada um com comportamentos distintos, mas compartilhando características comuns.

   

Desenvolvimento

Card (Model)

Representa a entidade básica do sistema com valor (1-13), naipe (enum Suit) e localização (mesa/jogador)

Implementa padrão de imutabilidade (propriedades somente leitura)

Métodos úteis: construtor de cópia e ToString() personalizado

Conexão teórica: Exemplo perfeito de tipo heterogêneo (combina inteiro, enum e bool)

Tipo heterogêneo que representa uma entidade básica do jogo, combinando dados distintos e exemplificando abstração e encapsulamento na OOP.

Suit (Model)

Enumeração que define os naipes (Hearts, Diamonds, Clubs, Spades)

Classe de extensão (SuitExtensions) adiciona métodos para símbolos Unicode e nomes amigáveis

Conexão teórica: Demonstra tipos enumerados como forma de restringir valores válidos

Enumeração que restringe valores válidos, ilustrando tipos enumerados e mostrando a conversão de dados em informação simbólica e visual.

Load (Model)

Classe estática para carregar cartas de arquivos CSV

Trata diferenças de sistemas operacionais (Windows/Linux paths)

Implementa tratamento de erros para arquivos não encontrados

Conexão teórica: Transforma dados brutos (arquivo) em informação estruturada (lista de Cards)

Transforma dados brutos de arquivos em objetos estruturados (informação), lidando com tipos heterogêneos e separando lógica de entrada de dados.

Show (View)

Classe para exibição no console (separação clara entre lógica e apresentação)

Dois métodos estáticos: show_cards() e show_histogram()

Conexão teórica: Responsável pela conversão de informação em representação visual

Converte informação estruturada em representação visual, exemplificando a separação de responsabilidades na OOP e uso de estruturas como listas.

Histogram (Controller)

Estrutura chave para análise: array de listas indexado por valores de cartas (1-13)

Método make_histogram() distribui as cartas nas posições correspondentes

Conexão teórica: Arranjo unidimensional onde cada elemento é uma lista (estrutura híbrida)

Utiliza arranjos unidimensionais com listas (estrutura híbrida) para análise de dados, ilustrando organização eficiente de dados em jogos.

Hands (Controller)

Classe abstrata base para todas as mãos de poker

Mantém cópia das cartas, histograma e lista de cartas encontradas

Define contrato com método find() a ser implementado pelas subclasses

Conexão teórica: Exemplo de abstração e herança na OOP

Classe abstrata com uso de herança e polimorfismo, exemplificando abstração de TADs e aplicação de estruturas de dados para detecção de padrões.

método de implementação

Foi modificado o uso dos arquivos .csv. Agora há 2 arquivos que compartilham a mesma mesa, mas as cartas na mão são diferentes

Foi duplicado o código Load, e modifiquei ele para analizar um arquvo .csv específico, Load1 para o primeiro arquivo, Load2 para o segundo arquivo

depois disso, baseado na identificação de mãos, e kickers em cada mão, será aplicado uma pontuação aos jogadores. Ex: carta alta, 10, terá um valor de 110 Um straightFlush com a maior carta sendo uma rainha, tera uma pontuação de 912, Baseada na pontuação, é decidido um vencedor ou um empate, 

quase todos os códigos de identificação foram modificados para retornar um valor que armazena um kicker, ou carta de maior valor na combinação da sua mão

Considerações Finais

Moysés Machado Neto - Eu fiz os códigos e implementações, ler o código base foi como ler um livro de magia negra amaldiçoado, por causa do peso que isso tem na sua sanidade. Não era nada que eu já não sabia, mas a forma que foi escrita. A implementação também foi complicada, pois eu tive que fazer umas gambiarras para funcionar, no código base. Eu aprendi o quão difícil é mexer no código dos outros.

Jean-Luc Silva Magalhães - introdução e itch.io: fazer a introdução foi simples, a parte mais dificil foi atualizar a pagina do itch.io e esperar todas as outras partes estarem prontas para transferir as informações, mas a comunicação entre os membros foi possível manter a ordem.

Beatriz Zardo A. - Montei a base dos slides e fiz parte da introdução e revisão dos parágrafos 6 a 10. A pesquisa não é complicada e a revisão para resumir os parágrafos foi simples. Alguns termos são complexos mas nada como uma boa pesquisa para ajudar a compreender melhor.

Rafael Augustinho Krigger - eu fiz a pesquisa sobre os tipos de dados e os arquivos .csv . A pesquisa não foi difícil, inclusive, eu aprendi até mais com a mesma. O que eu achei mais difícil foi fazer os arquivos .csv porque eu não estava entendendo como fazer os arquivos, mas com a ajuda dos colegas de equipe eu entendi melhor

Referências

Sites

Card Shuffling in C#

https://stackoverflow.com/questions/1150646/card-shuffling-in-c-sharp

C# in Cards

https://csharpinthecards.com/lesson/9

C# Implementation of a shuffle 

https://github.com/StefNewton/Deck-Of-Cards

Vídeos 

Shuffle and Deal with Arrays 

https://www.youtube.com/watch?v=KreWvnOgNa8

Equipe

Moysés Machado Neto - https://moyzinnn.itch.io

Rafael Augustinho Krigger - https://rafael-krigger.itch.io/

Beatriz Zardo A. - https://beetiredz.itch.io

Jean-Luc Silva Magalhães - https://jean-ms.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

César Albenes Zeferino | Diretor  Escola Politécnica

Giorgio Gilwan | Coordenador do  Curso: Design de Jogos

Rafael Kojiio | Coordenador  Gamelab