Estrutura de Dados Aplicada em Mãos de Pôquer
A downloadable tool
Introdução
Nesta disciplina foram abordados os conceitos fundamentais de estruturas de dados, dos tipos de dados e as formas em que podem ser organizadas. Sendo assim, foi definido o método de criar um jogo de pôquer com reconhecimento de mãos no estilo Texas Hold’em.
Para a produção deste projeto, o conteúdo passado em aula e os livros da biblioteca institucional indicados pelo professor Marcelo Dornbusch Lopes serviram como base para que o estudo e execução do projeto fosse possível.
O propósito deste trabalho é compreender e manipular conceitos de estruturas de dados e fazer um programa que reconheça as mãos de pôquer utilizando a linguagem C# e dentro dos padrões de um jogo estilo Texas Hold’em.
Para execução, utilizamos um Struct para registrar as características de uma carta, como o seu naipe e o seu valor. Essas cartas são armazenadas dentro de um histograma, um array que carrega 14 listas, separando as cartas pelo o seu valor. Acessamos esse array para comparar e distinguir entre as jogadas do pôquer.
A relevância deste projeto está no que se refere ao ensino e prática com viés para a aprendizagem e execução de conceitos fundamentais de estrutura de dados, incentivo ao exercício de raciocínio lógico e a como manipular dados, servindo para fins de carreira na área de programação.
Para as etapas do projeto, foi primeiramente foi preciso entender os conceitos para depois serem aplicados em códigos, também foram utilizados os livros indicados pelo professor Marcelo e exemplos de códigos fornecidos pelo mesmo como base e referência para facilitar o desenvolvimento do projeto. Começamos com os pseudo-códigos e em seguida, partimos para o desenvolvimento do código e testamos para ver se o programa consegue reconhecer.
Quanto aos critérios de avaliação, todos os códigos foram minuciosamente testados e se encontram funcionais.
Já em termos educacionais, este projeto serviu para ensinar a como compreender os conceitos de dados, estruturas e como aplicá-las.
Nos próximos capítulos serão mostrados respectivamente a fundamentação teórica para dados x informação e os tipos de dados. A estrutura de dados vem logo em seguida, detalhando as maneiras em que podem ser organizadas, como: arranjos unidimensionais, multidimensionais, estruturas clássicas, pilhas, filas e listas. Passamos em seguida pela definição de objetos e suas funções. E por fim, o desenvolvimento dos códigos e seus resultados.
Fundamentação Teórica
Dados são elementos brutos, inicialmente sem nenhum tipo de informação, que podem ser representados de várias formas, como numérico, em caracteres, nomes, etc. Já informação é o significado atribuído a esses dados, ao serem organizados e processados. Por exemplo, uma mão de poker (K de paus, K de ouros, 7 de paus, 2 de espadas e J de copas). A informação seria que isso é uma mão de Um Par; os dados são as cartas em si, sem mais nem menos.
2.1. Tipos de Dados
Dentro do âmbito de estrutura de dados existem os tipos de dados, os quais são:
- Dados homogêneos: se referem a um grupo de dados que possuem o mesmo tipo de dado, todos os elementos têm a mesma natureza, sendo assim, eles podem ser armazenados em uma única variável de mesmo nome. As principais vantagens são armazenar esses grupos de valores em uma única variável e poder acessar cada valor desse grupo de forma independente de acordo com sua posição. Elas também podem ser estruturas lineares ou não lineares, estáticas ou dinâmicas.
- Dados heterogêneos: se referem a um grupo de dados que possuem elementos de tipos diferentes, sendo assim, geralmente estamos lidando com um conjunto que pode ter números inteiros, strings, floats, objetos e outros tipos de dados misturados. As vantagens são a flexibilidade, já que você pode agrupar diferentes tipos de dados em uma única estrutura, o que pode ser muito útil para representar entidades complexas, como uma carta com naipe e valor (número da carta).
Tipos abstratos de dados: Os tipos abstratos de dados se referem a estruturas de que especificam o comportamento e interface que uma coleção de dados deve ter, mas não especificam como esses dados são implementados. Basicamente, é usado para descrever o que um conjunto de dados pode fazer, mas não necessariamente como essas operações são realizadas internamente. Suas principais vantagens são a abstração, que é o método usado para inserir, remover, buscar e acessar os dados. O encapsulamento, que serve para esconder a implementação, exibindo assim somente apenas o que é necessário para o sistema/usuário. A pilha, que serve para armazenar temporariamente um tipo de dado, mas diferente de do restante, a pilha tem uma característica de que o último dado que entra é o primeiro que sai (essa característica é conhecida como LIFO, (Last In, First Out), na qual a tradução fica, último a entrar, primeiro a sair), sendo assim, é sempre acessado na ordem inversa na qual foi inserida. Já a fila é muito parecida com a pilha, mas o diferencial está na ordem, a fila segue o princípio FIFO (First In, First Out), no qual o primeiro elemento a ser inserido é o último a ser removido.
2.2. Estruturas de Dados
Arranjos unidimensionais, também chamados de vetores, são estruturas de dados que armazenam uma sequência de elementos do mesmo tipo, organizados em uma única linha. Cada elemento do arranjo é acessado por um índice, que geralmente começa em 0. Eles são usados normalmente para armazenamento sequencial de dados, como pontuações em jogos por exemplo, e são muitas vezes uma base para estruturas mais complexas (arranjos bidimensionais).
Arranjos multidimensionais, também chamados de vetores multidimensionais, são estruturas de dados que estendem o conceito de arranjos unidimensionais para múltiplas dimensões. Os mais comuns são os arranjos bidimensionais, também conhecidos como matrizes, que também podem existir com 3 ou mais dimensões. Eles são ideais para armazenar dados em formato de tabela, como planilhas, tabuleiros ou mapas bidimensionais. São usados também para resolver problemas matemáticos e facilitam o armazenamento de dados relacionados entre si em múltiplas dimensões, como horários (dia e hora).
Agora, estruturas clássicas (pilhas, filas, listas), são fundamentais na programação e no desenvolvimento de algoritmos, pois permitem organizar e manipular conjuntos de dados de forma eficiente.
A pilha é uma estrutura que segue o princípio LIFO (Last In, First Out), ou seja, o último elemento inserido é o primeiro a ser removido. Elas são úteis para resolver problemas como a verificação de expressões matemáticas, controle de chamadas de funções recursivas e funcionalidades de desfazer/refazer.
A fila funciona segundo o princípio FIFO (First In, First Out), ou seja, o primeiro elemento a entrar é o primeiro a sair. Elas são muito utilizadas em sistemas que precisam manter a ordem de chegada, como em processos de impressão ou execução de tarefas em sistemas operacionais.
A lista é uma estrutura mais flexível. Ela permite armazenar uma coleção de elementos que podem ser inseridos ou removidos de qualquer posição. Elas são úteis quando se trabalha com dados dinâmicos, que mudam com frequência, já que não exigem um tamanho fixo como os vetores.
2.3. Orientação a Objetos
Classes é o nome dado na programação para blueprints utilizadas na criação de objetos. Elas definem a estrutura e o comportamento desses objetos especificando seus dados/atributos e suas funções/métodos.
Em Programação Orientada a Objetos em C++, Mohapatra descreve classes como: “Um grupo de objetos que compartilham propriedades similares para a parte de dados e para parte de programas.” ([2018]data provável)
Dentro de nossos objetos há dados e programas. Os dados são o Valor/Número da carta, o Naipe dela, e se ela é da Mesa ou do Jogador. (int: Value, Suit: Naipe, bool: da mesa.)
Nossos programas são então o que fazemos com esses objetos, por exemplo, nosso programa pega uma lista de cartas e verifica se nessa lista há uma condição para alguma jogada do pôquer.
No contexto de desenvolvimento de jogos, os objetos têm como função criar classes como, por exemplo, para personagens de algum jogo de RPG. É nessas classes que vão conter as informações de atributos, características de uma classe de personagem, as ações ou comportamentos em comum que vão compartilhar, ou as que vão servir para diferenciar as funções de cada classe.
Desenvolvimento dos códigos
Sequência Real
| 13,Clubs, true
1,Clubs,false 11,Clubs, true 12,Clubs,true 10,Clubs,false 10,Diamonds, true 1, Hearts, true |
|
| Link do Codigo para acompanhamento Sequência Real - 01 Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: contador (int), naipe (string), count_naipe (int) Início criar contador <- 1 criar existe <- false naipe <- “Clubs” count_naipe <- 0 // começa vendo se há um Ás, se houver verificamos se há outras cartas em rsequencia se histogram[1].Count > 0 faça: para i de 10 até 13 faça: se histogram[i].Count > 0 faça incrementa contador fim se fim para
naipe <- histogram[1].suite //Comparamos o naipe de cada carta com a do Ás, se for igual, incrementamos ao count_nipe para i = 10 ate 13 faça: se naipe == histogram[i].suite incrementa count_nipe fim se fim para // caso haja sequência e os naipes forem o mesmo retornamos existe como verdadeiro se contador == 5 && count_nipe == 4 faça: existe <- true retorna existe fim se
fim se retorna existe Fim | |
Sequência de Mesmo Naipe
| 6,Hearts,true
7,Hearts,false 10,Hearts,true 8,Hearts,true 9,Hearts,false 10,Diamonds,true 1, Clubs,true |
|
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: contador (int), primeiro_naipe (string), primeira_posição (int), posições (lista int), royale (bool), contador_royale (int) Início criar contador <- 1 criar contador_royale <- 1 criar royale <- false criar existe <- false criar primeiro_naipe <- “” criar primeira_posição <- 0 criar posições[] // verificamos se há sequência royale, caso haja, no final retornamos existe como falso se histogram[1].Count > 0 faça: para i de 10 até 13 faça: se histogram[i].Count > 0 faça incrementa contador_royale fim se fim para fim se se contador_royale == 5 royale <- true fim se para i de 1 até 11 faça: se histogram[i].Value > 0 faça: posições.adicionar[histrogram[i].Value] fim se fim para // colocamos a lista do menor para o maior e então comparamos o seu naipe e a diferença entre eles, caso a diferença seja maior que dois, não há uma sequencia do mesmo naipe posições.organizar para cada i em posições: se i == 0 faça: primeiro_naipe == histogram[i].Suit primeira_posição == posições continua fim se se histogram[i].Suit != primeiro_naipe faça: quebra fim se criar diferança_de_posições <- i - primeira_posição se diferença_de_posições > 2 faça: quebra fim se adicionar contador fim para
se contador == 5 & royale == false faça: existe = true fim se retorna existe Fim | |
Quadra
| 6,Spades,true
6,Hearts,true 6,Clubs,false 8,Hearts,true 6,Diamonds,true 10,Diamonds,true 1, Clubs,false |
|
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída: existe (bool) Auxiliar: … Início criar existe <- verdadeiro // verificamos se há uma lista com 4 valores para i de 1 a 13 faça: se histogram[i].Count == 4 faça: existe = verdadeiro quebra fim se fim para retorna existe … Fim | |
Full House
| 12,Clubs,true
12,Hearts,true 12,Diamonds,false 5,Spades,false 5,Hearts,true 3,Diamonds,true 2,Spades,true |  |
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: cont3, cont2 (bool) Início criar cont3 <- verdadeiro criar cont2 <- verdadeiro criar existe <- verdadeiro // checa se há uma lista com 3 valores para i de 1 até 13 faça: se histogram[i].Count == 3 cont3 <- verdadeiro fim se fim para // checa se há uma lista com 2 valores para i de 1 até 13 faça: se histogram[i].Count == 2 cont2 <- verdadeiro fim se fim para // caso haja retornamos existe como verdadeiro se cont3 && cont2 existe <- verdadeiro retorna existe fim se retorna existe Fim | |
Flush
| 1,Clubs,true
7,Clubs,true 9,Clubs,true 10,Clubs,false 5,Clubs,true 3,Diamonds,false 2,Spades,true |
|
Link do Codigo para acompanhamento Flush - 05 Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: count_naipe (int), naipe_atual (string) Início cria existe <- false // Inicializa a variável que indicará se há Flush cria count_naipe <- 0 // Contador para verificar o número de cartas de cada naipe cria naipe_atual <- "" // Armazena o naipe de cartas enquanto percorre o histograma\ // Para cada naipe (de 1 a 4) para i de 1 até 4 faça // 1 = Clubs, 2 = Diamonds, 3 = Hearts, 4 = Spades cria count_naipe <- 0 // Zera o contador de cartas para o naipe atual // Percorre todas as cartas (de 1 a 13) para verificar se há cartas do naipe atual para j de 1 até 13 faça se histogram[j].suite == i e histogram[j].Count > 0 então incrementa count_naipe // Incrementa o contador de cartas do naipe fim se fim para // Verifica se há pelo menos 5 cartas do mesmo naipe se count_naipe >= 5 então existe <- true // Encontrou um Flush retorna existe // Retorna imediatamente, pois encontrou um Flush fim se fim para
retorna existe Fim | |
Sequência
| 5,Clubs,true
6,Diamonds,true 7,Spades,true 8,Hearts,false 9,Clubs,true 12,Diamonds,false 2,Hearts,true |  |
Link do Codigo para acompanhamento Straight - 05 Entrada: histogram (List<Card>[14]) Saída: existe (bool) Auxiliar: contador (int), valores_sequencia (List<int>), carta_do_jogador (bool) Início criar existe ← false criar carta_do_jogador ← false criar lista valores ← [1, 2, ..., 13, 1] // para permitir Ás no final e início criar lista sequencia ← [] // extrair os valores únicos disponíveis do histograma para i ← 1 até 13 faça: se histogram[i].Count > 0 então: adiciona i na lista sequencia fim para // trata Ás no final (ex: 10-J-Q-K-A) se histogram[1].Count > 0 então: adiciona 14 na lista sequencia fim se ordenar sequencia em ordem crescente remover valores duplicados // verifica sequência de 5 valores consecutivos para i ← 0 até (sequencia.Count - 5) faça: criar contador ← 1 para j ← 1 até 4 faça: se sequencia[i + j] == sequencia[i] + j então: incrementa contador fim se fim para // se encontrou sequência de 5 valores se contador == 5 então: para cada valor na sequência encontrada faça: pega uma carta do histogram[valor] se carta.on_table == false então: carta_do_jogador ← true fim se fim para se carta_do_jogador == true então: existe ← true retorna existe fim se fim se fim para retorna existe Fim | |
Trinca ou Trio
| 10,Clubs,true
10,Spades,true 9,Hearts,true 10,Diamonds,false 3,Hearts,true 5,Diamonds,false 2,Hearts,true |
|
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar existe <- false //procuramos no histogram uma lista que haja 3 valores para i de 1 até 13 faça: //se houver retornamos existe como verdadeiro e saímos a função se histogram[i].Count maior ou igual a 3: existe <- true retornar existe fim se fim para retornar existe Fim | |
Dois Pares
| 10,Clubs,true
7,Spades,true 9,Hearts,true 10,Spades,false 5,Hearts,true 5,Diamonds,false 2,Hearts,true |
|
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar contador_pares criar existe // contamos do 1 até o 13 por pares para i de 1 até 13 faça: // caso já haja 2 pares saímos da função se contador_pares > 1 faça: existe <- true retornar existe fim se // se acharmos um par, somamos o contador de pares se histogram[i].Count == 2 faça: incrementar contador_pares fim se fim para retornar existe Fim | |
Um Par
| 11,Diamonds,false
11,Clubs, false 2,Diamonds,true 3,Hearts,true 4,Clubs,true 6,Diamonds,true 7, Hearts,true |
|
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar existe // contamos do maior até o menor verificando se há pares para i de 13 até 1 faça: // caso haja um par logo retornamos o existe como verdadeiro para sair da função se histogram[i].Count == 2 faça: existe <- true retornar existe fim se fim para
retornar existe Fim | |
Carta Alta
| 1,Diamonds,false
2,Diamonds,true 11,Hearts,true 2,Clubs,true 5,Clubs,false 7,Diamonds,true 13,Hearts,true |
|
Link do Codigo para acompanhamento Entrada: histogram (List<Card> [14]) Saída : existe (bool) Auxiliar: … Início criar mais_alta // verificamos se há um Ás na mão, caso haja retornamos o valor da carta se histogram[1].Count > 0 faça: mais_alta <- 1 retorna mais_alta // na ausência de um Ás, começamos da carta mais alta até a mais baixa, parando na primeira instância e retornamos o valor da carta para i de 13 até 2 faça: se histogram[i].Count > 0 faça: mais_alta <- i retorna mais_alta fim se fim para retorna mais_alta
Fim | |
Considerações Finais
Yasmin Adria Fornero: eventualmente, ao usufruir dos materiais indicados pelo professor, fui também atrás de tentar entender os códigos das mãos que eu estava fazendo, e felizmente, o resultado foi satisfatório. Compreender os tipos de dados e quais os valores cada uma armazena, de que maneiras podem ser organizadas numa estrutura de dados a modo que sejam eficientemente lidas através de um array, ou pilha, ou lista pelo programa. E também, conceitos como polimorfismo, que permitem que classes herdem e reutilizem informações outras, mas desempenhem papeis diferentes. Mais relacionado ao projeto, gerar o array para as cartas, para que o programa acesse o histograma e assim verifique num loop o tipo de mão específica em questão existe. Alguns de exemplos que pude compreender melhor a lógica por trás da sequência de linhas de códigos e a partir disso, desenvolver com mais facilidade, foram essas:
- Aqui é onde vai ser criada a lista e onde vai ser colocado os valores das cartas em ordem: List<Card> card_tmp = new List<Card>()
- Comando que vai começar a ler a lista para tentar encontrar pares: for (int i = 13; i >= 2; i--) valuesOrder.Add(i);. ‘for’ será tipo o comando de loop para verificar as cartas, o valor do ‘i’ será o parâmetro para leitura; “i >= 2” é o parâmetro para parar a contagem; “i--“ é o valor de “i” sendo diminuído em cada loop de maneira decrescente até chegar no 2.
- Aqui é onde o programa vai verificar se existe um par (2) daquele valor no histograma: if (histogram.data[i].Count >= 2)
Lucas Jordano: O desenvolvimento deste trabalho mostrou como o pré planejamento além de um bom entendimento de estrutura de códigos ajuda na produção de um projeto/jogo. Ele, na prática, ensina que a programação começa não no código, e sim no papel e caneta.
Diagramas e Fluxogramas mostraram a diferença de um sistema organizado, funcional e expansível, para um desorganizado e não funcional. Muitas vezes definir as variáveis no papel, ou em pseudo códigos, facilita e agiliza a escrita do código. Junto com o novo conhecimento sobre programação orientada a objetos, que ensina como melhor definir objetos e fazer sistemas agrupando-os em classes, assim ajudando com a manutenção de reutilização do código, novas portas se abrem para a produção de jogos.
Pedro Camargo: Esse projeto foi fundamental para aplicarmos na prática os conceitos de estruturas de dados e programação orientada a objetos. A minha maior dificuldade foi compreender os diferentes tipos de arranjos, principalmente como organizá-los e acessá-los corretamente no código. Mas com muita leitura e prática, consegui superar essa barreira. O material indicado pelo professor foi de grande ajuda nesse quesito, e agora penso que estou mais preparado para futuros desafios nessa área. Aqui tem um exemplo que me ajudou a entender melhor dados e vetores:
Imagine um simples programa que soma valores. Ambos os valores são dados que o programa guarda na memória para chegar ao resultado (que também é um dado). Para que uma calculadora possa te retornar o resultado de uma operação, ela precisa guardar os dados solicitados na memória e retornar o resultado.
var x= 1; //variável x recebe 1
var y= 5; // variável y recebe 5
z = x + y; // soma das duas variáveis
console.log(c) // retorno do resultado
Davi Costa: O projeto deu um certo trabalho, mas com a pesquisa feita em casa e usando o método de fazer pseudocódigo antes de realizar o código, o processo de criação começou a fluir bem. É nítido que o uso do pseudocódigo ajuda na melhor visualização do problema. Leonardo Guimarães: Como alguém que tem dificuldades em programação e poker, foi uma atividade desafiadora, mas que também acabou valendo a pena, e que foi bom de aprender, de aplicar os conceitos, e de melhorar o meu desenvolvimento na estrutura de dados.
Leonardo Guimarães: Como alguém que tem dificuldades em programação e poker, foi uma atividade desafiadora, mas que também acabou valendo a pena, e que foi bom de aprender, de aplicar os conceitos, e de melhorar o meu desenvolvimento na estrutura de dados.
Referências
Edelweiss, Nina. Algoritmos e programação com exemplos em Pascal e C [recurso eletrônico] / Nina Edelweiss, Maria Aparecida Castro Livi. – Dados eletrônicos. – Porto Alegre : Bookman, 2014. Editado também como livro impresso em 2014. ISBN 978-85-8260-190-7 - Disponível em: https://biblioteca-a.read.garden/viewer/9788582601907/163
Estrutura de dados [recurso eletrônico] / Adriana de Souza Vetorazzo... [et al.]; [revisão técnica : Jeferson Faleiro Leon de Souza Machado]. – Porto Alegre: SAGAH, 2018.ISBN 978-85-9502-393-2 - Disponível em: https://biblioteca-a.read.garden/viewer/9788595023932/capa
Estrutura de dados [recurso eletrônico] / Rafael Albuquerque Pinto... [et al.] ; [revisão técnica: Júlia Mara Colleoni Couto,Olimar Teixeira Borges]. – Porto Alegre : SAGAH, 2019.ISBN 978-65-81492-95-3 - Disponível em: https://biblioteca-a.read.garden/viewer/9786581492953/22
Estrutura de dados [recurso eletrônico] / Thiago Espíndola Cury... [et al.] ; [revisão técnica: Jeferson Faleiro Leon]. – Porto Alegre : SAGAH, 2018.ISBN 978-85-9502-432-8 - Disponível em: https://biblioteca-a.read.garden/viewer/9788595024328/capa
Gonçalves, Glauber Rogério Barbieri Sistemas de informação [recurso eletrônico] / Glauber Rogério Barbieri Gonçalves ; [revisão técnica: Jeferson Faleiro Leon]. – Porto Alegre : SAGAH, 2017. ISBN 978-85-9502-227-0 - Disponível em: https://biblioteca-a.read.garden/viewer/9788595022270/17
DALE, Nell Boylan; WALKER, Henry Mackay. Abstract Data Types 3.5: specifications, implementations and applications. Lexington, Massachusetts, Toronto: Heath, 1996. 752 p.
Dados homogêneos X heterogêneos
Object Oriented Programming in C#. Tutorials Teacher. Disponível em: https://www.tutorialsteacher.com/csharp/object-oriented-programming. Acesso em: 13 de mai. 2025.
PESSÔA FILHO, Joaquim. Programação orientada a objetos com C#. 2023. <i>1 e-book (122p. (Série Universitária). ISBN 9788539651726. (e-book) - Disponível em:
MOHAPATRA, Dr. Subasish. LECTURE NOTES ON Object Oriented Programming Using C++. Rourkela, Orissa, India: Department Of Computer Science And Application College Of Engineering And Technology, [2018]. 146 p.
DEVMEDIA. Principais conceitos da programação orientada a objetos. Disponível em: https://www.devmedia.com.br/principais-conceitos-da-programacao-orientada-a-objetos/26148. Acesso em: 10 maio 2025.
ALURA. O que é programação orientada a objetos? Disponível em: https://www.alura.com.br/artigos/poo-programacao-orientada-a-objetos. Acesso em: 28 abril 2025.
ROCKETSEAT. Programação orientada a objetos: princípios e boas práticas. Disponível em: https://www.rocketseat.com.br/blog/artigos/post/programacao-orientada-a-objetos-principios-e-boas-praticas. Acesso em: 15 abril 2025.
YOUTUBE. Classes, objetos, atributos, métodos, herança e polimorfismo. [S. l.]: YouTube. Disponível em: https://www.youtube.com. Acesso em: 10 maio 2025.
ALURA. Curso de Programação Orientada a Objetos. Disponível em: https://www.alura.com.br. Acesso em: 28 abril 2025.
RESEARCHGATE. Conceitos básicos de programação orientada a objetos. Disponível em: https://www.researchgate.net/publication/268362210. Acesso em: 10 maio 2025.
DEVMEDIA. Principais conceitos da Programação Orientada a Objetos. DevMedia. Disponível em: https://www.devmedia.com.br/principais-conceitos-da-programacao-orientada-a-objetos/32285. Acesso em: 10 maio 2025.
Equipe
Yasmin Adria Fornero - https://mimichiii.itch.io/
Lucas Jordano - https://wanii1.itch.io/
Davi Costa Freitas - https://cat77.itch.io/
Pedro Camargo - https://nhatroncions.itch.io/
Leonardo Guimarães - --
...
---------------------------------------------------------------------------------------------
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