Technical Design Document (TDD)

Sertão Místico (Jogo #07)

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

Sertão Místico utiliza uma arquitetura de Stacked Wilds com Pool Finito. A complexidade reside na necessidade de calcular múltiplas linhas vencedoras simultâneas enquanto mantém a ilusão de aleatoriedade visual.

A máquina renderiza: - Viewport Visível: 5x4 (20 símbolos) - Rolos Virtuais: 100-120 paradas cada (para suportar clusters de Wilds) - Cálculo de Linhas: Até 50 linhas calculadas simultaneamente

2. Integração com Pool Finito

2.1 Fluxo de Comunicação

[Servidor Lottopar] ↓ (Bilhete: R$ 50,00) [VLT Client] → Grid Engine (5x4) → Detecta 3 Fogueiras? → Se sim, ativa Bônus → Não ativa? → Calcula linhas vencedoras → Script Builder: Ajusta paradas para somar R$ 50,00 ↓ [Servidor Lottopar] (Valida + Registra)

2.2 Validação de Bilhete

TABLE Ticket_Validation ( ticket_id INT64 PRIMARY KEY, game_id INT (= 07), prize_amount DECIMAL(10,2), session_timestamp DATETIME, rtp_profile INT (90, 94, 97), wild_stacks_required INT, -- Quantos rolos precisam estar "cheios"? lines_target INT (40 ou 50), status ENUM('APPROVED', 'PENDING', 'REJECTED') )

3. Outcome Builder: Construção Reversa para Wilds Empilhados

3.1 Algoritmo de Seleção de Paradas

``` FUNCTION ConstructGrid(prize_amount, rtp_profile, lines_available): // Step 1: Determina quantos rolos precisam ser "cheios" de Wilds required_stacks = CalculateStacksNeeded(prize_amount, lines_available)

// Step 2: Seleciona quais rolos serão "cheios"
IF required_stacks >= 2:
    full_reels = [2, 3]  // Rolos 2 e 3 (mais visuais)
ELSE IF required_stacks == 1:
    full_reels = [3]     // Rolo 3 (centro)

// Step 3: Para cada rolo, escolhe um cluster de Wilds
FOR each reel in (1 to 5):
    IF reel in full_reels:
        // Escolhe um índice que coloca Wild stack inteiro na viewport
        reel_stop[reel] = SelectWildClusterStop(reel, rtp_profile)
    ELSE:
        // Reels normais: distribui símbolos diversos
        reel_stop[reel] = SelectNormalStop(reel, prize_amount)

// Step 4: Valida que a soma de linhas = prize_amount
total_lines_win = CalculateAllPayingLines(reel_stop)
IF total_lines_win != prize_amount:
    AdjustSymbolsForBalance(reel_stop, prize_amount - total_lines_win)

RETURN reel_stop[]

END FUNCTION ```

3.2 Exemplo Prático de Construção

``` Input: prize_amount = R$ 50,00, lines = 40, rtp = 94

Step 1: Calcula stacks necessários → 40 linhas * avg_payout_per_line ≈ R$ 1,25 por linha → Requer 2 rolos cheios de Wilds para conectar 40 linhas

Step 2: Seleciona Rolos 2 e 3 como "full"

Step 3: Escolhe paradas → Rolo 1: stop = 45 (símbolos baixos, alguns altos) → Rolo 2: stop = 35 (início de cluster = 5 Wilds seguidos) → Rolo 3: stop = 28 (início de cluster = 5 Wilds seguidos) → Rolo 4: stop = 50 (mistura para variedade) → Rolo 5: stop = 62 (símbolos baixos)

Step 4: Grid renderizado ┌─────────────┐ │ K [W] [W] [W] Q │ │ J [W] [W] [W] 10 │ │ A [W] [W] [W] A │ │ Q Onça Onça Onça K │ └─────────────┘

→ 40 linhas veem Wilds em 2-3 rolos → Soma de pagamentos = exatamente R$ 50,00 ```

4. Reel Strip Configuration (5 Rolos)

4.1 Estrutura de Fitas Longas

Rolo 1 (100 Paradas) - Filtro de Entrada

Índice | Símbolo | Frequência | Propósito ────────────────────────────────────────────────── 00-09 | A, K, Q, J | 10/100 | Símbolos baixos 10-19 | 10, 9 | 10/100 | Símbolos baixos 20-24 | Gavião | 5/100 | Raro 25-29 | [WILD] | 5/100 | Muito raro (filtro) 30-39 | A, K, Q, J | 10/100 | Filler 40-49 | Totem | 10/100 | Médio 50-59 | Onça | 10/100 | Alto (raro) 60-79 | A, K, Q, J | 20/100 | Filler 80-99 | [WILD] | 10/100 | Clusters isolados (2-3)

Rolo 2 (120 Paradas) - Centro Esquerdo (Alta Densidade Wild)

Índice | Símbolo | Propósito ────────────────────────────────────────────────── 00-04 | [WILD] x5 | Cluster A (Full-Reel) 05-14 | A-J, Símbolos Baixos | Spacer 15-19 | [WILD] x5 | Cluster B 20-24 | Onça, Gavião | High-value break 25-34 | Símbolos Baixos | Spacer 35-39 | [WILD] x5 | Cluster C ... (continua padrão)

Rolo 3 (120 Paradas) - Centro (Maior Densidade Wild)

Índice | Símbolo | Propósito ────────────────────────────────────────────────── 00-09 | [WILD] x10 | Mega Cluster (suporta 4 posições cheias) 10-19 | Símbolos Baixos | Break 20-29 | [WILD] x10 | Cluster B 30-34 | Totem, Amuleto | Medium break 35-44 | [WILD] x10 | Cluster C ... (continua padrão de clusters maiores)

Rolo 4 (120 Paradas) - Centro Direito (Alta Densidade)

Similar ao Rolo 2 (estratégia simétrica)

Rolo 5 (100 Paradas) - Filtro de Saída

Índice | Símbolo | Frequência | Propósito ────────────────────────────────────────────────── 00-14 | A, K, Q, J | 15/100 | Símbolos baixos (comum) 15-24 | 10, 9 | 10/100 | Símbolos baixos 25-34 | Totem | 10/100 | Médio 35-44 | Gavião | 10/100 | Alto (raro) 45-49 | [WILD] | 5/100 | Raro 50-59 | Onça | 10/100 | Muito raro 60-99 | A, K, Q | 40/100 | Filler massivo

4.2 Mapa de Clusters Wild (RTP 94%)

5. Cálculo de Linhas Vencedoras

5.1 Payline Evaluation Engine

``` FUNCTION EvaluateAllPaylines(grid[5][4]): total_win = 0 paying_lines = []

// Grid indexado: grid[reel][position]
// Posições: 0=top, 1=mid-top, 2=mid-bottom, 3=bottom

FOR line_num = 1 TO 40:
    payline = GetPaylineSymbols(line_num, grid)
    // payline = [symbol_reel1, symbol_reel2, ..., symbol_reel5]

    win_amount = CheckPaylineWin(payline)
    IF win_amount > 0:
        paying_lines.Add({line: line_num, win: win_amount})
        total_win += win_amount

RETURN {total_win: total_win, paying_lines: paying_lines}

END FUNCTION ```

5.2 Exemplo de Payline (Line 15)

``` Payline 15: top-middle-middle-middle-bottom

Grid: Reel1 Reel2 Reel3 Reel4 Reel5 Position 0: K [W] [W] [W] Q Position 1: J [W] [W] [W] 10 Position 2: A [W] [W] [W] A ← Line 15 Position 3: Q Onça Onça Onça K

Symbols on line 15: A, [W], [W], [W], A

Win Check: → A + Wild + Wild + Wild + A = "A com 3 Wilds = pay como 4xA" → Lookup paytable: 4x A = 25 créditos → Multiply by bet per line: 25 * 0,50 = R$ 12,50

Line 15 wins R$ 12,50 ```

5.3 Paytable de Linhas

6. RTP Adjustment e Stack Probability

6.1 Tabela de Probabilidades de Stack

``` TABLE Stack_Probability ( rtp_profile INT, stack_height INT, occurrence_rate DECIMAL(5,4) )

Data: (90, 2, 0.6000), -- RTP 90: 60% chance de stack de altura 2 (90, 3, 0.3000), -- 30% chance de stack de altura 3 (90, 4, 0.0900), -- 9% chance de full reel (90, 8, 0.0100), -- 1% chance de mega stack

(94, 2, 0.5000), (94, 3, 0.4500), (94, 4, 0.0400), (94, 8, 0.0100),

(97, 2, 0.3000), (97, 3, 0.4500), (97, 4, 0.2000), -- 20% chance (muito mais que RTP 90) (97, 8, 0.0500), -- 5% chance ```

6.2 Algoritmo de Seleção de Altura

``` FUNCTION SelectStackHeight(reel_id, rtp_profile): rand_value = RNG.Next(0, 1.0)

probabilities = GetStackProbabilities(rtp_profile)
cumulative = 0

FOR each (height, prob) in probabilities:
    cumulative += prob
    IF rand_value <= cumulative:
        RETURN height

// Fallback
RETURN 2

END FUNCTION ```

7. Free Spins Mechanics

7.1 Gatilho e Ativação

``` FUNCTION CheckScatterTrigger(grid[5][4]): scatter_count = 0 scatter_positions = []

FOR reel = 2 TO 4:  // Apenas Rolos 2, 3, 4
    FOR position = 0 TO 3:
        IF grid[reel][position] == FOGUEIRA:
            scatter_count++
            scatter_positions.Add({reel, position})

IF scatter_count >= 3:
    RETURN {triggered: TRUE, free_spins: 5, positions: scatter_positions}
ELSE:
    RETURN {triggered: FALSE}

END FUNCTION ```

7.2 Modificação de Rolos em Free Spins

``` TABLE FreeSpins_RollModification ( reel_id INT, modification STRING, effect STRING )

Data: (1, 'REDUCE_BLANKS', 'Remove 20% dos símbolos baixos'), (2, 'BOOST_WILDS', 'Aumenta clusters de Wilds para 10-15 altura'), (3, 'BOOST_WILDS', 'Aumenta clusters de Wilds para 10-15 altura'), (4, 'BOOST_WILDS', 'Aumenta clusters de Wilds para 10-15 altura'), (5, 'REDUCE_BLANKS', 'Remove 20% dos símbolos baixos'), ```

7.3 Retrigger Probability

``` FUNCTION CheckRetrigger(free_spins_grid[5][4]): scatter_count = CountScatters(free_spins_grid[2:4][*])

IF scatter_count >= 3:
    rtp_profile = GetCurrentRTPProfile()

    retrigger_chance = LOOKUP_TABLE[rtp_profile]
    // RTP 90: 4% (1 em 25)
    // RTP 94: 8% (1 em 12)
    // RTP 97: 12% (1 em 8)

    IF RNG.Next(0, 1.0) < retrigger_chance:
        RETURN {retriggered: TRUE, additional_spins: 5}

RETURN {retriggered: FALSE}

END FUNCTION ```

8. G2S/SAS Protocol Integration

8.1 SAS 7.03 Configuration

SAS_CONFIG: machine_id: 0x0007 denomination: BRL max_bet: 50 (R$ 0,50 * 100 linhas) max_win: 1000000 (1 milhão de créditos teórico) game_features: 0x0C // Progressive + Bonus + Multiline reel_type: 3 // Virtual reels (digital)

8.2 Polling de Status

9. Hardware Requirements

10. VltCore.dll Dependencies

VltCore.dll ├── Reel Engine (5x4 Grid) │ ├── Strip Manager (120 paradas por rolo) │ ├── Cluster Selector │ └── Collision Detector (linhas vencedoras) ├── Wild Stacking Engine │ ├── Stack Height Selector │ ├── Full-Reel Detector │ └── Visual Smooth Renderer ├── Payline Calculator │ ├── 40/50-line evaluator │ ├── Multi-symbol substitution │ └── Prize aggregator ├── Free Spins Manager │ ├── Scatter Detection │ ├── Reel Modification │ └── Retrigger Logic └── Communication Module ├── Pool Finito Parser ├── RTP Adjustment └── SAS Handler

11. Seed Management e Auditoria

11.1 RNG Seed Chain

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

// Gera os 5 reel stops
FOR reel = 1 TO 5:
    reel_stop[reel] = state.NextInt(reel_stop_range[reel])

// Determina se há scatter
IF HasScatter(reel_stop):
    child_seed_1 = state.NextInt(2^32)  // Para gerar free spins
    child_seed_2 = state.NextInt(2^32)  // Para retrigger

    SAVE_TO_LOG(parent_seed, child_seed_1, child_seed_2)

RETURN {reel_stop[], child_seed}

END FUNCTION ```

11.2 Audit Trail

TABLE Audit_Trail ( event_id INT PRIMARY KEY, session_id INT64, spin_number INT, parent_seed BIGINT, reel_stops VARCHAR(20), -- "34,56,28,50,62" grid_result VARCHAR(500), -- JSON com grid completo paylines_won INT, total_win DECIMAL(10,2), child_seeds VARCHAR(100), -- Próximos seeds (se bônus) timestamp DATETIME, auditor_verified BOOLEAN DEFAULT FALSE )

12. Fluxo Completo de Sessão

``` 1. Jogador Aposta R$ 0,50 (40 linhas @ R$ 0,01 cada) → Envia BET ao servidor → Aguarda seed

1. Servidor Retorna OUTCOME → seed = 0x7FA3B8C2D1E9F0A1 → reel_stops = [34, 56, 28, 50, 62]

2. Client Calcula Grid → Rolo 2, stop 56 = Cluster de Wilds (5 de altura) → Rolo 3, stop 28 = Cluster de Wilds (10 de altura) → Rolos 2 e 3 aparecem "cheios" de Wilds

3. Avalia Linhas → 40 linhas com Wilds pagam → Total: R$ 50,00 (seed + estrutura garantem isso)

4. Mostra Animação → Orquestra épica toca → Jogador vê tela "explodindo" de Wilds → Animação dura 5-10 segundos

5. Registra Resultado → Audit trail atualizado → Servidor confirma

6. Se Scatter Gatilhado (sim, neste exemplo) → Free Spins Mode ativado → 5 giros grátis com rolos modificados → Mesmo processo se repete (mas com stack chances aumentadas) ```

13. Error Handling e Fallback

``` IF grid_calculation_failed: ALERT "Grid Error Detected" FORCE_MANUAL_PAYOUT_MODE LOCK_MACHINE_UNTIL_AUDIT

IF scatter_detection_conflict: // Ex: 4 scatters, mas sistema registrou 3 RECALCULATE using recorded_outcome IF mismatch_persists: REPORT_TO_SERVER for manual resolution

IF free_spins_retrigger_exceeds_limit: // Proteção contra loops infinitos MAX_RETRIGS = 15 // máximo 15 retriggers por sessão IF exceeds: FORCE_END_BONUS PAYOUT_REMAINDER ```

14. Testes de Validação Mínimos

Fim do TDD - Sertão Místico

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.