Technical Design Document (TDD)

Jogo 20 - O Código Secreto

Versão: 1.0 Data: 2026-04-03 Mercado: Brasil (Paraná - Lottopar) Arquitetura: Pool Finito + Dual Constraint Solver

1. Visão Geral Técnica

O Código Secreto implementa o mais complexo algoritmo deste portfólio: Um Constraint Solver duplo que valida simultaneamente: 1. Padrões de Bingo nas 4 cartelas 2. Coleta de 6 números específicos (Código)

A inovação: As bolas são geradas PRIMEIRO, as cartelas DEPOIS (oposto dos outros jogos).

2. Estrutura de Bilhete

```json { "ticket_id": "TKT-20-20260403-001", "bingo_prize": 100, "code_prize": 0, "total_prize": 100,

"winning_cartela": 2, "winning_bingo_pattern": "SINGLE_LINE",

"code_numbers": [05, 15, 25, 35, 45, 55], "code_completion": false,

"drawn_balls": [05, 15, 25, 12, 33, 35, 18, 41, 27, 45, ...], "total_balls_to_draw": 30,

"constraint_metadata": { "cartela_1_must_not_match": ["BINGO", "PERIMETER"], "cartela_2_partial_marks": 4, // Vai marcar 4 para chegar a linha depois "cartela_3_safe_numbers": [...] } } ```

3. Algoritmo de Construção (Reverse Builder)

3.1 Fluxo Crítico: Bolas Primeiro, Cartelas Depois

``` ENTRADA: - Bilhete: Bingo Prize = R$ 100 (Linha), Code Prize = R$ 0 (Não completo)

PASSO 1: Definir Código Secreto ├─ Código = [05, 15, 25, 35, 45, 55] │ (Números que podem ser sorteados ou não, dependendo do prêmio de Código) └─ Se Code Prize = R$ 0 → Código aparecerá em ~3 das 30 bolas (por acaso)

PASSO 2: Gerar as 30 Bolas (ANTES das Cartelas!) ├─ Incluir obrigatoriamente: alguns números do Código (se pagando) ├─ Distribuição: [05, 15, 25, 12, 33, 35, 18, 41, 27, 45, ...] └─ Total: 30 bolas ordenadas

PASSO 3: Gerar Cartelas (AGORA, com Constraint) ├─ Preencher Cartela 1: Números aleatórios que NÃO completam bingo ├─ Preencher Cartela 2: Números que completarão exatamente 1 linha ├─ Preencher Cartela 3: Números aleatórios ├─ Preencher Cartela 4: Números aleatórios └─ Validação: Com as 30 bolas, apenas Cartela 2 completa padrão (e Cartelas 1, 3, 4 NÃO completam Bingo acidentalmente)

PASSO 4: Validação Final ├─ Rodar simulação: Sortear as 30 bolas ├─ Verificar Código: Quantos dos 6 foram coletados? (Deve ser 3) ├─ Verificar Bingo: Qual padrão completado? (Deve ser Linha em Cartela 2) └─ Se validação falhar: RETRY com diferentes números de cartela ```

3.2 Código C# - Dual Constraint Solver

```csharp public class DualConstraintSolver { private List drawnBalls = new(); private int[][] cartelas = new int[4][]; private List codeNumbers; private decimal targetBingoPrize; private decimal targetCodePrize;

public BingoConfiguration BuildConfigurationReverseMode(
    List<int> codeNumbers,
    decimal bingoPrize,
    decimal codePrize,
    int maxRetries = 100)
{
    this.codeNumbers = codeNumbers;
    this.targetBingoPrize = bingoPrize;
    this.targetCodePrize = codePrize;

    // PASSO 1: Gerar bolas (com ou sem números do código)
    drawnBalls = GenerateDrawnBalls(codeNumbers, codePrize);

    // PASSO 2: Tentar gerar cartelas válidas
    int retryCount = 0;
    while (retryCount < maxRetries)
    {
        cartelas = GenerateCartelasAroundBalls(codeNumbers, bingoPrize);

        // Validar
        if (ValidateConfiguration())
        {
            return new BingoConfiguration
            {
                DrawnBalls = drawnBalls,
                Cartelas = cartelas,
                CodeNumbers = codeNumbers,
                ValidBingo = true,
                ValidCode = (codePrize > 0)
            };
        }

        retryCount++;
    }

    // FALLBACK: Se não conseguir, usar configuração padrão
    return GenerateDefaultConfiguration();
}

private List<int> GenerateDrawnBalls(List<int> codeNumbers, decimal codePrize)
{
    var balls = new List<int>();

    if (codePrize > 0)
    {
        // Se código vai ser completo, incluir TODOS os números do código
        balls.AddRange(codeNumbers);
    }
    else
    {
        // Se código não completa, incluir ~50% dos números (aleatório)
        var random = new Random();
        var codeSubset = codeNumbers
            .Where(x => random.Next(0, 2) == 0)
            .ToList();
        balls.AddRange(codeSubset);
    }

    // Preencher com números aleatórios
    var usedNumbers = new HashSet<int>(balls);
    while (balls.Count < 30)
    {
        int randomBall = new Random().Next(1, 91);
        if (!usedNumbers.Contains(randomBall))
        {
            balls.Add(randomBall);
            usedNumbers.Add(randomBall);
        }
    }

    // Embaralhar (parecer aleatório)
    Fisher_YatesShuffle(balls);
    return balls;
}

private int[][] GenerateCartelasAroundBalls(List<int> codeNumbers, decimal bingoPrize)
{
    var cartelas = new int[4][];
    int winningCartelaIndex = new Random().Next(0, 4);

    for (int i = 0; i < 4; i++)
    {
        if (i == winningCartelaIndex)
        {
            // Esta cartela vai ganhar
            cartelas[i] = GenerateWinningCartela(bingoPrize);
        }
        else
        {
            // Cartelas perdedoras
            cartelas[i] = GenerateNonWinningCartela();
        }
    }

    return cartelas;
}

private int[] GenerateWinningCartela(decimal bingoPrize)
{
    // Gerar cartela que completa padrão com as 30 bolas sorteadas
    var cartela = new int[15];
    var random = new Random();

    // Determinar quantos números da bola já são suficientes para ganhar
    int patternLength = GetPatternLength(bingoPrize);
    var necessaryNumbers = drawnBalls.Take(patternLength).ToList();

    // Preencher cartela com os números necessários
    for (int i = 0; i < necessaryNumbers.Count; i++)
    {
        cartela[i] = necessaryNumbers[i];
    }

    // Preencher resto com números aleatórios
    for (int i = necessaryNumbers.Count; i < 15; i++)
    {
        int randomNum = random.Next(1, 91);
        while (cartela.Contains(randomNum) || drawnBalls.Contains(randomNum))
        {
            randomNum = random.Next(1, 91);
        }
        cartela[i] = randomNum;
    }

    Fisher_YatesShuffle(cartela);
    return cartela;
}

private int[] GenerateNonWinningCartela()
{
    // Cartela que NÃO completa nenhum prêmio com as 30 bolas
    var cartela = new int[15];
    var random = new Random();

    for (int i = 0; i < 15; i++)
    {
        int randomNum = random.Next(1, 91);

        // CRITÉRIO: Número NÃO deve estar entre as 30 bolas sorteadas
        // (A menos que combinado com outros, não cause vitória)
        while (drawnBalls.Contains(randomNum) || cartela.Contains(randomNum))
        {
            randomNum = random.Next(1, 91);
        }

        cartela[i] = randomNum;
    }

    Fisher_YatesShuffle(cartela);
    return cartela;
}

private bool ValidateConfiguration()
{
    // Simulação de sorteio
    int codeCollected = 0;
    BingoPattern bingoResult = BingoPattern.NONE;

    foreach (int ball in drawnBalls)
    {
        // Contar código
        if (codeNumbers.Contains(ball))
        {
            codeCollected++;
        }

        // Verificar bingo
        foreach (int cartelaIndex = 0; cartelaIndex < 4; cartelaIndex++)
        {
            var pattern = CheckPattern(cartelas[cartelaIndex], drawnBalls);
            if (pattern != BingoPattern.NONE && cartelaIndex != 0) // Cartela 0 não deve ganhar
            {
                bingoResult = pattern;
                break;
            }
        }
    }

    // Validar
    bool codeValid = (targetCodePrize == 0 && codeCollected < 6)
                  || (targetCodePrize > 0 && codeCollected == 6);

    bool bingoValid = bingoResult != BingoPattern.NONE;

    return codeValid && bingoValid;
}

} ```

4. Detecção Dual (Bingo + Código)

```csharp public class DualGameEventDetector { public class GameResult { public BingoPattern BingoPattern; public int CodeNumbersCollected; public decimal BingoPrize; public decimal CodePrize; public decimal TotalPrize; }

public GameResult DetectResult(List<int> drawnBalls, List<int> codeNumbers)
{
    // Conta código simultâneo com bingo
    int codeCount = drawnBalls.Intersect(codeNumbers).Count();

    // Detecta padrão de bingo (como sempre)
    var bingoPattern = patternDetector.CheckPattern(drawnBalls);

    return new GameResult
    {
        BingoPattern = bingoPattern,
        CodeNumbersCollected = codeCount,
        BingoPrize = GetBingoPrize(bingoPattern),
        CodePrize = GetCodePrize(codeCount),
        TotalPrize = GetBingoPrize(bingoPattern) + GetCodePrize(codeCount)
    };
}

private decimal GetCodePrize(int numbersCollected)
{
    return numbersCollected switch
    {
        6 => 10000m,  // JACKPOT
        5 => 200m,
        4 => 50m,
        3 => 25m,
        2 => 10m,
        1 => 5m,
        _ => 0m
    };
}

} ```

5. Animação do Cryptex

```csharp public class CryptexAnimator : MonoBehaviour { public void RevealCodeNumber(int numberIndex, bool isCollected) { if (isCollected) { // Girar anel para mostrar número StartCoroutine(RotateCryptexRing( ringIndex: numberIndex, angle: 360f, duration: 0.8f, easeFunction: EaseOutQuad));

        // Som
        audioManager.Play("code_reveal.wav");

        // Efeito de luz
        CryptexRings[numberIndex].GetComponent<Light>().Intensity = 1.5f;
    }
}

public void CompleteCode()
{
    // Todos os 6 anéis completados
    StartCoroutine(OpenSafe());
}

private IEnumerator OpenSafe()
{
    // Sequência épica
    audioManager.Play("safe_opening.wav");

    // Rotação de todos os anéis simultaneamente
    for (int i = 0; i < 6; i++)
    {
        StartCoroutine(RotateCryptexRing(i, 720f, 2.0f, EaseOutBounce));
        yield return new WaitForSeconds(0.1f);
    }

    yield return new WaitForSeconds(2.5f);

    // Explosão/Abertura
    particleSystem.Play();
    cameraShake.Shake(duration: 0.5f, intensity: 0.3f);
}

} ```

6. Banco de Dados

```sql CREATE TABLE code_secret_rounds ( code_round_id INTEGER PRIMARY KEY AUTOINCREMENT, round_id INTEGER NOT NULL,

code_numbers TEXT, -- JSON [5, 15, 25, 35, 45, 55]
code_numbers_collected INT DEFAULT 0,
code_prize DECIMAL(10, 2) DEFAULT 0,

bingo_pattern VARCHAR(50),
bingo_prize DECIMAL(10, 2),

total_prize DECIMAL(10, 2),

timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,

FOREIGN KEY (round_id) REFERENCES game_rounds(round_id)

); ```

7. Performance

``` Constraint Solver Retries: Máx 100 CPU per Configuration Build: ~5 ms Total Config Time: < 50 ms

Runtime per round: ├─ Ball drawing: 1 ms ├─ Code detection: 0.5 ms ├─ Bingo detection: 1.5 ms └─ Total: < 5 ms ```

8. Testes QA

Versão

v1.0 - 2026-04-03 Arquiteto: Algorithm/Backend - Oktop.AI Status: Pronto para Implementação

Prompts de Geração de Arte IA

Clique em qualquer prompt para copiar. Os prompts abaixo são otimizados para Midjourney v6, DALL-E 3, e Stable Diffusion.