20232-team-2
O poker é um jogo de cartas amplamente praticado em diversas variações. A seguir, apresentamos um resumo das regras básicas do poker, que podem ser adaptadas conforme a variante específica do jogo:
O objetivo principal do poker é ganhar fichas ou dinheiro, que são apostados pelos jogadores ao longo das rodadas.
As mãos de poker são classificadas de acordo com a combinação de cartas que um jogador possui. Sendo elas: 1)Royal Flush = 100 pontos. 2)Straight Flush = 90 pontos. 3)Quadra = 80 pontos. 4)Full House = 70 pontos. 5)Flush = 60 pontos. 6)Straight = 50 pontos. 7)Trinca = 40 Pontos. 8)Dois Pares = 30 pontos. 9)Um Par = 20 Pontos. 10)Nenhum dos anteriores = {A pontuação será dada de acordo com a maior carta na mão do jogador, com seus valores dados entre 2 e 14, 2 equivale a própria carta 2, 14 equivalente ao Ás}
O jogo consiste em rodadas de apostas, onde os jogadores têm a oportunidade de apostar, aumentar, igualar ou desistir.
Cada jogador receberá 1000 unidades em fichas no início de cada jogo e as apostará durante as rodadas. As apostas podem ser forçadas (small e big blind) ou voluntárias (apostas normais). Blinds e Antes:
Alguns jogos de poker começam com apostas forçadas chamadas "blinds" e/ou "antes" para iniciar o pote.
Composta por cinco cartas. A partir da da segundada rodada elas começam a serem mostradas respectivamente na ordem três, uma e uma totalizando as cinco cartas. Desempate:
Conhecimento das mãos iniciais fortes e estratégias de combinação de cartas é crucial para o sucesso no poker. Desistência (Fold):
Os jogadores podem desistir de uma mão a qualquer momento, abrindo mão das fichas apostadas até o momento.
Showdown:
Após a última rodada de apostas, se mais de um jogador permanecer, ocorre o showdown, revelando as cartas e determinando o vencedor.
A classe Carta representa uma carta de baralho para um jogo de Poker. Abaixo está um resumo dos seus conteúdos:
Esta classe oferece uma maneira de criar e manipular cartas de baralho, elementos fundamentais em muitos jogos de cartas. Cada instância da classe representa uma carta com um valor (rank) e um naipe específico
naipes_possiveis: Este array estático contém os possíveis naipes que uma carta pode ter: "Ouros" , "Espadas", "Copas" e "Paus".
Este é o construtor da classe Carta. Ele recebe dois parâmetros: valorCarta, que é o valor da carta, e naipe, que é o naipe da carta. Inicializa as variáveis de instância valorCarta e naipe com os valores fornecidos.
Este é o destrutor da classe Carta. Ele não realiza nenhuma ação.
Este método retorna o valor da carta.
Este método retorna o naipe da carta.
Este método retorna as cartas na mão como um std::vector de objetos Carta.
Este método calcula e retorna o valor da mão com base nas regras do poker. Ele verifica se a mão atende aos critérios de vários tipos de mãos de poker, como Par, dois Pares, Trinca, Straight, Flush, Full House, Quadra, Straight Flush, Royal Flush, respectivamente ordenada com seus valores crescentes. Se a mão não atender aos critérios de nenhum desses tipos, o método ordena as cartas por valor e retorna o valor da carta mais alta. O valor da mão é utilizado para determinar o vencedor em um jogo de poker.
Verificar se há duas cartas do mesmo valor na mao. Retornará true caso existam e false caso contrário.
Verifica se a mão contém Dois Pares.
Verifica se a mão contém uma Trinca (three-of-a-kind).
Verifica se a mão contém um Straight (cinco cartas sequenciais).
Verifica se a mão contém um Flush (cinco cartas do mesmo naipe).
Verifica se a mão contém um Full House (um par e uma trinca).
Verifica se a mão contém uma Quadra (four-of-a-kind).
Verifica se a mão contém um Straight Flush (um straight e um flush).
Verifica se a mão contém um Roayal Flush.
Este método é utilizado para ordenar cartas com base em seus valores. Recebe dois objetos Carta como argumentos e retorna true se o valor da primeira carta for menor que o valor(int) da segunda carta.
Este método é utilizado para ordenar cartas com base em seus naipes. Se os naipes das duas cartas forem iguais, elas são ordenadas com base em seus valores. Caso contrário, são ordenadas com base em seus naipes.
Este método é utilizado para adicionar um objeto Carta ao vetor cartas, que representa a mão do jogador em um jogo de cartas.
Cada método faz uma cópia ordenada das cartas, utilizado para não modificar a sequência real das cartas, e verifica se atendem aos critérios específicos do tipo de mão de poker.
A classe Jogador tem o propósito de representar um jogador em um jogo de poker. O código fornece métodos para gerenciar a mão do jogador, receber cartas, desistir e realizar apostas, além de atributos essenciais para o jogo, como o saldo.
Este método retorna o apelido do jogador. É um método getter, utilizado para acessar o nome que o usuário escolheu utilizar no jogo, não podemos ter dois usuários com nomes iguais.
Descrição: Retorna a mão do jogador (mao). Tipo de Retorno: Objeto Mao (Mão).
Descrição: Retorna o valor da mão do jogador. Tipo de Retorno: Inteiro.
Descrição: Retorna a quantia que o jogador apostou (apostado). Tipo de Retorno: Inteiro.
Descrição: Retorna o saldo do jogador (saldo). Tipo de Retorno: Inteiro.
Retorna verdadeiro se o jogador estiver ativo, falso caso contrário.
Retorna verdadeiro se o jogador for o small blind, falso caso contrário.
Retorna verdadeiro se o jogador for o big blind, falso caso contrário.
Retorna verdadeiro se o jogador estiver em estado all-in, falso caso contrário.
Retorna verdadeiro se for a vez do jogador agir, falso caso contrário.
Retorna verdadeiro se o jogador deu check, falso caso contrário.
Retorna verdadeiro se for a primeira rodada de apostas, falso caso contrário.
Retorna verdadeiro se a partida estiver finalizada, falso caso contrário.
Descrição: Define o status ativo do jogador. Parâmetro: _ativo - Booleano.
Descrição: Define a quantia apostada pelo jogador. Parâmetro: valor - Inteiro.
Define o status do jogador como small blind. Parâmetro: Booleano.
Define o status do jogador como big blind. Parâmetro: Booleano.
Define se é a vez do jogador agir. Parâmetro: Booleano.
Define se o jogador está em estado all-in. Parâmetro: Booleano..
Este é o construtor da classe Jogador. Recebe um parâmetro nick do tipo string, que representa o apelido do jogador. O construtor inicializa o apelido do jogador com o valor fornecido, define o status do jogador como ativo (ativo = true), e inicializa várias outras variáveis booleanas como falsas. Além disso, configura as fichas do jogador com denominações e quantidades específicas, define o saldo do jogador (saldo) como 1000, e inicializa a quantidade apostada pelo jogador (apostado) como 0. (Para fazer uso do polimorfismo(modo competitivo(todos os jogadores iniciam com a mesma quantidade de fichas) ou cast game(utiliza dinheiro para comprar fichas)) esse método t)
Este é o destrutor da classe Jogador. Não realiza nenhuma ação porque a classe não possui nenhum espaço de memória alocado dinamicamente que precisa ser liberado.
Este método reinicia a mão do jogador. Ele cria um novo objeto Mao e atribui à variável mao.
Permite que o jogador receba uma carta, adicionando-a à mão do jogador usando o método adicionar_Carta do objeto mao.
Permite que o jogador desista. Solicita confirmação e, se o jogador digitar "SIM", define a bandeira ativo como false, indicando que o jogador não está mais ativo.
Método de aposta que interage com o usuário para lidar com diferentes cenários. Inclui verificações para apostar o saldo total como "all-in" e apostas específicas com fichas. Retorna true se a aposta for bem-sucedida; caso contrário, retorna false.
Este método é utilizado para exibir as informações do jogador. Imprime o apelido do jogador, a quantidade de fichas de cada tipo que o jogador possui, o saldo total e se o jogador cobriu a aposta mais alta na mesa. Também indica se o jogador é o small blind ou big blind na rodada atual. Parâmetro: ValorMesa - Inteiro representando a aposta mais alta na mesa.
Descrição: Este método é utilizado para aumentar o saldo do jogador (saldo). Adiciona o valor fornecido (_saldo) ao saldo do jogador e, em seguida, chama o método converte_Sobressalente com _saldo como argumento. Parâmetro: _saldo - Inteiro representando o valor a ser adicionado ao saldo.
Este método é utilizado para converter as fichas do jogador de um tipo para outro. O jogador escolhe o tipo de ficha que deseja converter, o tipo de ficha para o qual deseja converter, bem como a quantidade de fichas a serem convertidas. O método verifica se o jogador possui fichas suficientes do tipo escolhido e se a quantidade de fichas a ser convertida é suficiente para obter pelo menos uma ficha do tipo desejado. Se essas condições forem atendidas, o método realiza a conversão.
Este método converte uma quantidade especificada de dinheiro (aposta_em_fichas) em fichas de várias denominações. Começa com a denominação mais alta e percorre até a mais baixa, convertendo o máximo possível de dinheiro em fichas em cada etapa. Estes métodos da classe Jogador fornecem funcionalidades para exibir informações, aumentar o saldo e realizar conversões de fichas, sendo essenciais para a interação e o funcionamento do jogador em um jogo de poker.
A classe Dealer em C++ gerencia um jogo de poker, com métodos para designar papéis, iniciar partidas, criar salas, baralhos e controlar fases do jogo.
Retorna o baralho, que é um vetor de objetos Carta (Card). Representa o baralho atual de cartas que o dealer possui. Tipo de Retorno: Vetor de Carta.
Retorna a mesa, que também é um vetor de objetos Carta. Provavelmente representa as cartas que estão atualmente na mesa. Tipo de Retorno: Vetor de Carta.
Retorna os jogadores, que é um vetor de objetos Jogador (Player). Representa os jogadores no jogo. Tipo de Retorno: Vetor de Jogador.
Retorna o valorMesa. Pode representar a aposta ou valor atual no pote na mesa. Tipo de Retorno: Inteiro.
Retorna o primeiro_Jogador. Pode representar o jogador que inicia a rodada. Tipo de Retorno: Inteiro.
Define o valorMesa para o valor inteiro fornecido. Parâmetro: valorMesa - Inteiro.
Adiciona o valor inteiro fornecido ao valor_Acumulado_mesa. Pode representar o valor total das apostas feitas na mesa ao longo de várias rodadas. Parâmetro: valorAtualMesa - Inteiro.
Define o primeiro_Jogador para o valor inteiro fornecido, provavelmente representando o ID do primeiro jogador. Parâmetro: id_Primeiro_Jogador - Inteiro.
Define a primeira_Aposta para o valor inteiro fornecido. Pode representar a primeira aposta feita em uma rodada. Parâmetro: primeira_Aposta - Inteiro.
Este é o construtor da classe Dealer. Inicializa várias variáveis de membro com seus valores padrão. rodada é definido como 1, indicando o início do jogo. check é definido como 0, e é usada para rastrear quantos jogadores verificaram suas mãos. primeiro_Jogador é definido como -1, valor inexistente no jogo, mas utilizado para indicar que nenhum jogador foi definido como o primeiro. valor_Acumulado_mesa é definido como 0, indicando que nenhuma aposta foi feita ainda. primeira_Aposta é definido como 10, valor inicial mínimo da aposta(aumentará em 10 a cada partida). small_blind_apostou é definido como 0, indicando que o jogador do small blind ainda não fez uma aposta. valorMesa é definido como o valor de primeira_Aposta, indicando que a aposta ou valor atual no pote na mesa é igual à aposta inicial. partidaFinalizada é definido como falso, indicando que o jogo ainda não está finalizado.
Atribui o papel de Small Blind ao próximo jogador na lista, ciclando se necessário.
Atribui o papel de Big Blind de maneira semelhante ao designar_Small_Blind().
Designa o primeiro jogador a jogar na rodada, considerando o Small Blind inicial e lidando com jogadores inativos.
Inicia o jogo, criando a sala, atribuindo papéis, distribuindo cartas e iniciando quatro rodadas de apostas. Finaliza a rodada se houver apenas um jogador com dinheiro restante.
Cria a sala do jogo, solicitando o número e apelidos dos jogadores, definindo aleatoriamente o Big Blind e atribuindo o Small Blind ao próximo jogador.
Cria e embaralha um baralho padrão de 52 cartas.
Cria as cartas comunitárias (a "mesa") simulando as fases "flop", "turn" e "river".
Embaralha o baralho usando a função std::random_shuffle da Biblioteca Padrão do C++.
Distribui duas cartas para cada jogador, define estados iniciais e exibe as cartas.
Passa a vez para o próximo jogador ativo.
Verifica se todos os jogadores ativos deram check.
Verifica se a rodada atual acabou, reinicia apostas e incrementa o contador de rodadas. Define partidaFinalizada como true se atingir a quarta rodada.
Exibe um número especificado de cartas de uma lista fornecida, lidando com cartas de face separadamente das numeradas.
Não implementado no código fornecido, provavelmente lidaria com o fim do jogo.