Este projeto foi inspirado no jogo Balatro.
Não temos qualquer intenção de monetizar, distribuir comercialmente ou violar direitos autorais.
O desenvolvimento deste jogo é exclusivamente para fins de estudo e aprendizado em programação e design de jogos.
O objetivo do jogo é formar mãos com combinações de cartas que gerem a maior pontuação possível, manipular o deck e criar estratégias. Ao final de cada rodada, se o jogador atingir a pontuação necessária, ele vence, passando para a próxima fase. O objetivo é alcançar a maior pontuação possível, utilizando os curingas à disposição.
O jogo utiliza um baralho padrão de 52 cartas (sem curingas, salvo variação combinada). Cada carta tem valor numérico e naipe.
Valores:
Números 2 a 10: valor nominal.
A (Ás): 11 pontos.
Q (Dama), K (Rei) e J (Valete): 10 pontos.
Cada jogador recebe uma quantidade fixa de cartas (8 cartas).
A mão é composta pelas cartas que o jogador possui na sua vez.
O jogador deve analisar sua mão para formar combinações de valor.
- Sequência (Straight): cartas consecutivas do mesmo naipe. Ex: 5♠ 6♠ 7♠
- Trinca (Three of a Kind): três cartas de mesmo valor. Ex: 7♣ 7♦ 7♥
- Quadra (Four of a Kind): quatro cartas de mesmo valor.
- Flush: cinco cartas do mesmo naipe, não necessariamente em sequência.
Blinds e ante são como as “fases” do jogo, cada ante tem 3 blinds diferentes: small, big e boss.
Ao iniciar o jogo o jogador estará na ante 1 small blind. Caso o jogador consiga atingir a pontuação necessária, ele avança para a ante 1 big blind; se conseguir novamente, avança ao boss blind. Ao derrotar o boss blind, o jogador avança para a ante 2 — o ciclo se repete até a ante 12.
Cada combinação possui um valor de pontuação específico:
O objetivo do descarte é eliminar cartas que, no momento, não favorecem a criação de combinações fortes, dando a chance de receber cartas melhores após o descarte.
O jogador começa uma rodada com 3 descartes. Cada descarte pode ser de 1 até 5 cartas.
Após descartar, essas cartas não poderão mais ser utilizadas na rodada.
O mesmo número de cartas descartadas será comprado do deck (se disponível).
Exemplo: se o jogador descarta 5 cartas, mas restam apenas 3 no deck, ele comprará apenas 3.
A Loja é o espaço onde o jogador pode gastar dinheiro ($) para adquirir Curingas.
Ela aparece apenas após vitórias em determinadas fases, como Small Blind, Big Blind ou Boss Blind.
Funciona como uma fase de compras entre batalhas, permitindo fortalecer a estratégia antes de prosseguir.
O Reroll permite ao jogador pagar dinheiro para trocar as cartas disponíveis na loja por novas opções.
Cada reroll exibe três novas cartas aleatórias no lugar das anteriores.
O custo começa em $2 e aumenta em $1 a cada uso, voltando para $2 ao abrir uma nova loja.
Curingas são a principal ferramenta do jogo — capazes de gerar pontuação, manipular o deck e criar economia.
Eles não são jogados junto às cartas do baralho comum.
O jogador pode possuir até 5 curingas na mão e vender qualquer um a qualquer momento.
Curingas têm diferentes raridades, que afetam no seu custo para compra
Os quatro pilares da Programação Orientada a Objetos (POO) foram aplicados da seguinte forma:
Aplicado para proteger dados críticos como o dinheiro do jogador (PlayerCoins), controlado pelo GameManager.cs.
Apenas métodos públicos (AddCoins, SpendCoins) podem alterar esse valor.
// O 'private set' garante que só o GameManager pode definir o valor
public int PlayerCoins { get; private set; } = 4;
public void AddCoins(int amount)
{
if (amount > 0)
PlayerCoins += amount;
}
public void SpendCoins(int amount)
{
if (amount > PlayerCoins) return;
PlayerCoins -= amount;
}
Motivo: protege a variável de alterações indevidas e centraliza a lógica de validação.
Utilizada para reutilizar código entre Card e JokerCard, ambas derivadas da classe base BaseCard.cs.
public abstract partial class BaseCard : TextureRect
{
public string Name { get; protected set; }
public bool IsSelected { get; private set; }
}
public partial class Card : BaseCard
{
public CardData Data { get; private set; }
}
public partial class JokerCard : BaseCard
{
private List<IJokerEffect> _effects = new();
public int Cost { get; private set; }
}
Motivo: evita duplicação de código e mantém a lógica comum em um único local.
Utilizamos a interface IJokerEffect para padronizar o comportamento dos efeitos de curingas,
sem expor detalhes de implementação.
public interface IJokerEffect
{
string Description { get; }
void Apply(HandValue.HandResult result);
}
Implementações concretas:
public class EffectAddChips : IJokerEffect
{
private int _chips;
public void Apply(HandValue.HandResult result)
{
result.ChipsBase += _chips;
}
}
public class EffectMultiplyMultiplier : IJokerEffect
{
private float _factor;
public void Apply(HandValue.HandResult result)
{
result.MultBase = (int)(result.MultBase * _factor);
}
}
Motivo: o JokerCard apenas chama effect.Apply(result) — sem precisar saber o tipo específico do efeito.
Usado para que Card e JokerCard tenham comportamentos diferentes ao sobrescrever métodos herdados da BaseCard.
protected virtual void HideTooltip() { }
protected override void HideTooltip()
{
base.HideTooltip();
if (tooltip != null)
{
tooltip.QueueFree();
tooltip = null;
}
}
Motivo: permite comportamentos distintos para cada tipo de carta (ex: tooltips diferentes), usando a mesma chamada.
Para rodar o Royal Poker localmente, siga as etapas abaixo:
-
Instale o .NET Framework mais recente
Baixe a versão atual diretamente pelo site oficial da Microsoft:
https://dotnet.microsoft.com/pt-br/download -
Baixe e extraia o arquivo
RoyalPoker.zip
Após o download, descompacte o arquivo em uma pasta de sua preferência. -
Execute o arquivo
RoyalPoker.exe
Dentro da pasta extraída, localize e abra o executável para iniciar o jogo.
Após seguir esses passos, o jogo estará pronto para uso na sua máquina! 🎮
Desenvolvido por DotsEng.Studio