Technical Design Document (TDD)

Diamantes do Garimpo (Jogo #10)

Versão: 1.0 Data: 2026-04-03 Mercado: VLT Paraná / Lottopar Compliance: GLI-11, SAS 7.03, G2S 1.4

1. Visão Geral da Arquitetura

Diamantes do Garimpo implementa o sistema mais sofisticado do portfólio:

┌─────────────────────────────────────┐ │ PHANTOM BUFFER SYSTEM │ ├─────────────────────────────────────┤ │ [5 Colunas x 10 Linhas Ocultas] │ │ (Símbolos pré-carregados) │ ├─────────────────────────────────────┤ │ VIEWPORT (Área Visível) │ │ [5 Colunas x 3 Linhas Visíveis] │ └─────────────────────────────────────┘ ↓ (Quando explosão) Símbolos caem do Buffer

O software não gera símbolos aleatoriamente na hora. Ele pré-carrega uma matriz de 5x10 com todos os símbolos que irão cair nas próximas cascatas.

2. Estrutura de Dados: Phantom Buffer

2.1 Matrix Definition

```cpp typedef struct { int symbol_id; // ID do símbolo (0-11) bool is_winning_line; // Pertence a linha vencedora? int cascade_number; // Que cascata este símbolo "cairá"? } GridCell;

GridCell grid[5][10]; // 5 colunas x 10 linhas (50 células) // Linhas 0-2: Visíveis // Linhas 3-9: Phantom Buffer ```

2.2 Inicialização de Grid

``` FUNCTION InitializeGrid(parent_seed, prize_amount, rtp_profile): state = RNG_Initialize(parent_seed)

// Step 1: Backward Construction
cascades_script = GenerateCascadesScript(prize_amount)

// Step 2: Preenche Grid com símbolos
FOR col = 1 TO 5:
    FOR row = 0 TO 9:
        symbol_id = SelectSymbolForCascade(
            col, row,
            cascades_script,
            state,
            rtp_profile
        )
        grid[col][row].symbol_id = symbol_id

// Step 3: Marca células vencedoras
MarkWinningCells(grid, cascades_script)

RETURN grid

END FUNCTION ```

3. Outcome Builder: Backward Construction

3.1 Algoritmo de Geração de Cascatas

``` FUNCTION GenerateCascadesScript(prize_amount): // Exemplo: prize_amount = R$ 80 = 400x (aposta de 20 créditos)

cascades = []
remaining = prize_amount

// Cascata 0 (Giro Inicial)
cascade_0_win = SelectLineWinValue(remaining, rtp_profile)
// Retorna R$ 10 (primeira cascata)
cascades[0] = {
    win_amount: 10,
    multiplier: 1x,
    line_pattern: [0, 0, 0, 0, 0]  // Linha horizontal no topo
}
remaining -= 10  // R$ 70 restante

// Cascata 1
cascade_1_win = SelectLineWinValue(remaining, rtp_profile)
// Retorna R$ 35 (pode ser multiplicado por 2x)
cascades[1] = {
    win_amount: 35,
    multiplier: 2x,
    line_pattern: [1, 1, 1, 1, 1]  // Linha no meio
}
remaining -= (35 * 2)  // Remaining = 70 - 70 = 0

// Se remaining ainda > 0, adiciona mais cascatas
// Se remaining == 0, Kill Screen (próximos símbolos não formam linha)

cascades[2] = {
    win_amount: 0,
    multiplier: 1x,
    line_pattern: KILL_SCREEN  // Nenhuma linha vence
}

RETURN cascades

END FUNCTION ```

3.2 Script de Exemplo Prático

``` Prize: R$ 80 (400 multiplicador / aposta 20 créditos)

Cascatas necessárias: Cascata 0: 100 (1x) = 100 Cascata 1: 150 (2x) = 300 Cascata 2: 0 (Kill Screen) Total: 400 ✓

Símbolos colocados: Viewport inicial (linhas 0-2): Pepitas (100x valor) Phantom linha 3-4: Esmeralds (150x valor) Phantom linha 5+: Mistura sem padrão vencedor ```

4. Cálculo de Linhas e Multiplicadores

4.1 Evaluation Engine

``` FUNCTION EvaluateAllLines(grid[5][3]): total_win = 0 paying_lines_count = 0

FOR line_num = 1 TO 20:
    payline_cells = GetPaylineCells(line_num, grid)
    // payline_cells = [cell(reel1, pos), cell(reel2, pos), ...]

    IF IsMatchingLine(payline_cells):
        base_win = CalculateLineValue(payline_cells)
        cascade_number = GetCascadeNumber(payline_cells)
        multiplier = GetMultiplierForCascade(cascade_number)

        line_win = base_win * multiplier

        total_win += line_win
        paying_lines_count++

RETURN {
    total_win: total_win,
    paying_lines: paying_lines_count,
    average_multiplier: total_win / paying_lines_count
}

END FUNCTION ```

4.2 Multiplicador por Cascata

``` Tabela de Multiplicadores (RTP 94%):

Cascata 0 (Spin Inicial): 1x Cascata 1 (1ª queda): 2x Cascata 2 (2ª queda): 3x Cascata 3+ (3ª+ quedas): 5x

Free Spins Modificado: Cascata 0: 3x Cascata 1: 6x Cascata 2: 9x Cascata 3+: 15x (travado para não aumentar mais) ```

5. Reel Strip Configuration

5.1 Estrutura de Fitas Longas (150-200 Paradas)

Rolo 1 (150 Paradas)

Índice Símbolo Propósito ──────────────────────────────────────────── 00-14 Picareta x15 Cluster A 15-24 Símbolos Baixos Spacer 25-39 Diamante x15 Cluster B (raro) 40-49 Ouro x10 Cluster C ... (continua padrão)

Rolo 3 (180 Paradas) - Centro (Máxima Densidade)

Índice Símbolo Propósito ──────────────────────────────────────────── 00-09 Pepita x10 Cluster A (comum) 10-24 Baixos Spacer 25-34 Dinamite x10 Cluster B (Wild) 35-49 Baixos Spacer 50-64 Esmeralda x15 Cluster C (jackpot) ... (padrão se repete)

5.2 Density Map

6. Decay Rate: Probabilidade de Continuidade

6.1 Tabela de Decay (RTP Profiles)

``` TABLE Decay_Probability ( rtp_profile INT, cascade_num INT, continuation_rate DECIMAL(5,4) )

Data: RTP 90%: (90, 0→1, 0.20), -- 20% chance cascata 1 ocorra (90, 1→2, 0.40), -- 40% chance cascata 2 ocorra (90, 2→3, 0.30), -- 30% chance cascata 3 ocorra (90, 3→4, 0.10), -- 10% chance cascata 4 ocorra

RTP 94%: (94, 0→1, 0.25), (94, 1→2, 0.55), -- "Moment of Inertia" (94, 2→3, 0.45), (94, 3→4, 0.25),

RTP 97%: (97, 0→1, 0.30), (97, 1→2, 0.70), -- Muito maior! (97, 2→3, 0.65), (97, 3→4, 0.50), -- Possibilidade realista de 5+ cascatas ```

6.2 Verificação de Continuidade

``` FUNCTION ShouldContinueCascade(cascade_num, rtp_profile): decay_prob = LOOKUP_TABLE[rtp_profile][cascade_num]

if RNG.Next(0.0, 1.0) < decay_prob:
    RETURN TRUE  // Próxima cascata acontece
ELSE:
    RETURN FALSE  // Kill Screen - fim da jogada

END FUNCTION ```

7. Free Spins Mechanics

7.1 Trigger Detection

``` FUNCTION CheckMineEntranceTrigger(grid[5][3]): trigger_count = 0 trigger_lines = []

FOR line_num = 1 TO 20:
    payline = GetPaylineSymbols(line_num, grid)

    IF CountSymbols(payline, MINE_ENTRANCE) >= 3:
        trigger_count++
        trigger_lines.Add(line_num)

IF trigger_count >= 3:
    RETURN {
        triggered: TRUE,
        initial_spins: 6,
        trigger_lines: trigger_lines
    }
ELSE:
    RETURN {triggered: FALSE}

END FUNCTION ```

7.2 Reel Modification em Free Spins

``` FUNCTION ModifyReelsForFreeSpins(): // Remove símbolos baixos dos rolos FOR each reel in (1 TO 5): low_value_symbols = [PICARETA, BATEIA] FOR symbol in low_value_symbols: COUNT_IN_REEL[reel][symbol] *= 0.6 // Remove 40%

// Aumenta densidade de Wilds
FOR each reel:
    DENSITY[reel][DINAMITE] *= 1.3

// Aumenta multiplicador base
// (multiplicador começa em 3x em vez de 1x)

END FUNCTION ```

7.3 Retrigger Mechanics

``` MAX_RETRIGS_PER_SESSION = 15

FUNCTION CheckFreeSpinsRetrigger(free_spins_grid[5][3]): retrig_count = CountMineEntrances(free_spins_grid)

IF retrig_count >= 3 AND current_retrigs < MAX_RETRIGS_PER_SESSION:
    // Multiplicador fica travado em 15x para resto do bônus
    LOCK_MULTIPLIER = 15x

    RETURN {
        retriggered: TRUE,
        additional_spins: 5,
        multiplier_locked: TRUE
    }
ELSE:
    RETURN {retriggered: FALSE}

END FUNCTION ```

8. SAS/G2S Integration

8.1 SAS 7.03 Configuration

SAS_CONFIG: machine_id: 0x000A denomination: BRL max_bet: 20 (créditos fixos) max_win: 50000000 (50 milhões teórico com cascatas) game_features: 0x0C // Bonus + Cascading reel_type: 3 // Virtual reels

8.2 Critical Polling

9. Hardware Requirements (Demanding!)

10. Seed Management Complexo

10.1 Seed Chain para Cascatas

``` FUNCTION GenerateCascadingOutcome(parent_seed): state = RNG_Initialize(parent_seed)

// Cascata 0 (Giro inicial)
FOR col = 1 TO 5:
    FOR row = 0 TO 2:
        grid[col][row] = SelectSymbol(state.NextInt())

// Seed para cascata 1
cascade_1_seed = state.NextInt(2^32)
// ... preenche linhas 3-4 do buffer

// Seed para cascata 2
cascade_2_seed = state.NextInt(2^32)
// ... preenche linhas 5-6

// Continue até não haver mais cascatas

RETURN {
    grid: grid,
    cascade_seeds: [cascade_1_seed, cascade_2_seed, ...],
    final_payout: calculated_total
}

END FUNCTION ```

10.2 Audit Logging Completo

``` TABLE Cascade_Audit ( cascade_id INT PRIMARY KEY, session_id INT64, spin_number INT, parent_seed BIGINT,

-- Para cada cascata
cascade_0_seed BIGINT,
cascade_0_grid JSON,
cascade_0_payout DECIMAL(10,2),
cascade_0_multiplier INT,

cascade_1_seed BIGINT,
cascade_1_grid JSON,
cascade_1_payout DECIMAL(10,2),
cascade_1_multiplier INT,

... (até 10 cascatas possíveis)

total_cascade_count INT,
total_payout DECIMAL(10,2),
original_prize DECIMAL(10,2),
timestamp DATETIME,
auditor_verified BOOLEAN

) ```

11. Validation & Safety Checks

11.1 Sum Validation

``` FUNCTION ValidateCascadingSum(cascades_data, original_prize): calculated_total = 0

FOR cascade in cascades_data:
    win = cascade.win_amount
    multiplier = cascade.multiplier
    calculated_total += (win * multiplier)

IF calculated_total != original_prize:
    ALERT "Cascading Outcome Sum Mismatch"
    LOG_CRITICAL {
        expected: original_prize,
        calculated: calculated_total,
        difference: original_prize - calculated_total
    }

    // Segurança: Sempre paga o prêmio original
    FORCE_PAYOUT = original_prize
    REQUEST_AUDIT

RETURN (calculated_total == original_prize)

END FUNCTION ```

11.2 Cascade Limit Protection

``` MAX_CASCADES = 10 // Limite de segurança

IF cascade_count > MAX_CASCADES: ALERT "Cascade Limit Exceeded" FORCE_KILL_SCREEN() // Para todas cascatas PAYOUT = current_accumulated_total LOG_EVENT type: "SAFETY_TRIGGER" ```

12. Performance Optimization

12.1 Rendering Pipeline

``` Phase 1: Background Render (off-screen) → Phantom Buffer (linhas 3-9) pré-renderizado

Phase 2: Viewport Render → Apenas linhas 0-2 visíveis em tempo real → Atualiza a cada frame (queda de símbolos)

Phase 3: Cascade Animation → Cria camadas de partículas para explosão → Interpolação linear para queda (não RNG, determinístico visualmente) ```

12.2 Memory Management

``` Pré-alocação: - Buffer de 5x10 = 50 células (permanente) - Cache de texturas (1000+ sprites) = 500MB GPU - Partícula pool = 10.000 particles pré-alocados

Durante cascata: - Nada é alocado dinamicamente - Apenas modificação de valores em matriz existente - Reutilização de particle pool ```

13. Validation Tests

14. Troubleshooting Guide

Fim do TDD - Diamantes do Garimpo

Versão 1.0 | Oktop.AI | 2026-04-03

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.