Technical Design Document (TDD) - Tesouros da Amazônia

Projeto: 01 - Tesouros da Amazônia Versão: 1.0 Data: 2026-04-03 Mercado: Brasil (Paraná / Lottopar) Plataforma: VLT Cloud-based + Local Client

1. Arquitetura de Sistema

1.1 Visão Geral da Integração

┌─────────────────────────────────────────────────┐ │ SERVIDOR CENTRAL (Lottopar) │ │ PoolFinito + Outcome Determination │ └────────────────────┬────────────────────────────┘ │ TCP/IP + HTTPS │ (G2S Protocol) ┌───────────┴────────────┐ │ │ ┌────▼─────┐ ┌─────▼────┐ │ VLT │ │ VLT │ │Terminal1 │ │Terminal2 │ │VltCore │ │VltCore │ └────────────┘ └─────────────┘

1.2 Componentes Principais

1. Pool Finito Server (Lottopar): Determina prêmios
2. Outcome Builder: Reverses o prêmio em combinações de símbolos
3. Reel Engine: Controla paradas dos rolos virtuais
4. Game Logic: Máquina de estados (Free Spins, Coleta de Cristais)
5. RNG (Seeded): RNG local para posições de parada (post-seed baseado em Pool)

2. Integração com Pool Finito

2.1 Fluxo de Pagamento

``` 1. Jogador aperta GIRAR └─> Envia aposta (R$ 2,00) + ID da máquina

1. Servidor Lottopar: ├─> Verifica saldo da máquina ├─> Sorteia prêmio (ex: R$ 40,00 = 20x aposta) ├─> Envia código criptografado com prêmio └─> Registra em log de auditoria

2. Cliente VLT: ├─> Recebe resposta do servidor ├─> Decodifica prêmio ├─> Passa para Outcome Builder └─> Outcome Builder gera combinação de símbolos

3. Reel Engine: ├─> Para rolos de forma a exibir símbolos ├─> Toca animações de ganho └─> Atualiza saldo do jogador ```

2.2 Exemplo Prático: Fluxo de Prêmio R$ 40

Input do Servidor: OUTCOME_ID: 0x7F2E, PRIZE: 4000 (em centavos), BONUS_TRIGGER: NO

Outcome Builder Logic: ``` OUTCOME_BUILDER CLASS: INPUT: prize = 4000 (centavos) INPUT: rtp_mode = "94" INPUT: reel_strips = [virtualReels1, ..., virtualReels5]

ALGORITHM: possible_combinations = findAllCombinations(reel_strips) // Retorna todas as combinações que pagam 4000 // Exemplo: [WildWildOnçaJacaré, WildArara...]

IF possible_combinations.isEmpty():
  // Fallback: Decomposição com Scatters + Bônus
  TRIGGER_BONUS = TRUE
  additional_prize_from_bonus = 4000 - base_win
ELSE:
  selected = possible_combinations[random(0, length)]
    // Seleciona uma combinação válida
  RETURN selected  // Ex: [2, 12, 18, 5, 8] = índices de paradas

```

3. Reel Strip Configuration

3.1 Layout Geral (1024 Ways)

• Total de Rolos: 5
• Altura de Rolos: 3 linhas visíveis por rolo
• Total de Paradas Virtuais: Rolo 1 a 5, cada com 40 a 60 paradas

3.2 Distribuição Detalhada (Configuração RTP 94%)

Rolo 1 (Iniciador - 40 Paradas)

Rolo 2 (Coração - 50 Paradas)

Rolo 3 (Coração - 50 Paradas)

Idêntico ao Rolo 2 (simetria para equilíbrio)

Rolo 4 (Coração - 50 Paradas)

Idêntico ao Rolo 2 (densidade máxima de Wilds)

Rolo 5 (Finalizador - 40 Paradas)

3.3 Near Miss Engineering

Para implementar "quase-ganho" psicologicamente efetivo: - Rolo 5: Onça é colocada nos índices 00, 18, 35. Então, brancos são colocados em 01, 19, 36. - Resultado: Jogador vê Onça passando frequentemente "quase" na linha de pagamento. - Efeito: Aumenta antecipação de bônus sem alterar RTP.

4. RTP Adjustment Mechanism

4.1 Alteração de Reel Strips por RTP

Configuração 90%: json { "reel_density": { "wild_count": [4, 4, 4, 4, 3], // Wilds reduzidos "scatter_count": [8, 10, 10, 10, 3], // Scatters reduzidos "top_symbol_count": [0, 0, 0, 0, 1], // Onça rara no rolo 5 "retrigger_frequency": "1/25" }, "multiplier_weights": { "wild_multiplier_2x": 0.80, // 80% chance de 2x "wild_multiplier_3x": 0.20 // 20% chance de 3x } }

Configuração 94% (Padrão): json { "reel_density": { "wild_count": [4, 5, 5, 5, 3], // Wilds balanceados "scatter_count": [8, 12, 12, 12, 3], // Scatters equilibrados "top_symbol_count": [0, 0, 0, 0, 2], // Onça mais frequente "retrigger_frequency": "1/18" }, "multiplier_weights": { "wild_multiplier_2x": 0.60, "wild_multiplier_3x": 0.40 } }

Configuração 97%: json { "reel_density": { "wild_count": [4, 6, 6, 6, 3], // Wilds aumentados "scatter_count": [10, 14, 14, 14, 4], // Scatters abundantes "top_symbol_count": [0, 0, 0, 0, 3], // Onça comum "retrigger_frequency": "1/12" }, "multiplier_weights": { "wild_multiplier_2x": 0.40, "wild_multiplier_3x": 0.60 } }

4.2 Hot-swap de Configuração

```csharp public class RTPConfig { public enum RTPlevel { Mode90, Mode94, Mode97 }

public static void LoadRTPMode(RTPlevel mode) { ReelStrips reels = LoadReelsFromFile($"reel_strips_{mode}.bin"); PoolEngine.SetMultiplierWeights(mode); OutcomeBuilder.SetDensity(reels); Logger.Info($"RTP Mode changed to {mode}"); } } ```

5. Máquina de Estados (Game State Machine)

5.1 Estados Principais

┌──────────────┐ │ IDLE │ (Aguardando aposta) └──────┬───────┘ │ Jogador clica GIRAR ▼ ┌──────────────┐ │ SPINNING │ (Rolos girando) └──────┬───────┘ │ Resultado recebido ▼ ┌──────────────┐ │ SHOWWIN │ (Exibindo ganho) └──────┬───────┘ │ ├─────────────────────┐ │ │ ▼ ▼ IDLE ┌───────────────────┐ (Sem bônus) │ FREE_SPINS │ (Bônus ativado) └─────┬─────────────┘ │ ┌───┴────────────────┐ │ │ ▼ ▼ COLLECT_CRYSTAL RETRIGGER_CHECK (Acumular Cristais) (Verificar 3+ Scatters) │ │ └───────┬────────────┘ │ ┌──────┴──────┐ │ │ ▼ ▼ BONUS_END MORE_SPINS (Encerrar) (Adicionar 5 giros)

5.2 Transições de Estado (Pseudo-código)

```csharp enum GameState { Idle, Spinning, ShowWin, FreeSpins, CollectCrystal }

public class GameStateMachine { private GameState currentState = GameState.Idle; private int crystalCount = 0; private int freeSpinsRemaining = 0;

public void OnSpinClicked(decimal bet) {
    if (currentState != GameState.Idle) return;
    currentState = GameState.Spinning;

    // Requisita outcome do servidor
    Outcome outcome = PoolEngine.FetchOutcome(bet);

    // Passa para Outcome Builder
    int[] reelStops = OutcomeBuilder.GetReelStops(outcome.Prize, outcome.RTPMode);

    // Simula giro
    SimulateReels(reelStops);

    // Verifica ganho e bônus
    int winAmount = CalculateWin(reelStops);
    if (outcome.BonusTriggered) {
        currentState = GameState.FreeSpins;
        freeSpinsRemaining = 10;
        crystalCount = 0;
        MessageBox.Show("AMAZÔNIA DESPERTOU!");
    } else {
        currentState = GameState.Idle;
    }
}

public void OnFreeSpinComplete(int[] reelStops) {
    // Verifica Scatters para coleta de cristal
    int scatterCount = CountScatters(reelStops);
    if (scatterCount > 0) {
        crystalCount += scatterCount;
        UpdateCrystalUI(crystalCount);
        CheckSymbolTransformation(crystalCount);
    }

    freeSpinsRemaining--;

    if (freeSpinsRemaining == 0) {
        currentState = GameState.Idle;
        ShowBonusComplete();
    }
    // Se ainda há giros ou retrigger, permanece em FreeSpins
}

private void CheckSymbolTransformation(int crystals) {
    if (crystals >= 4 && crystals < 8) {
        // Estado 1: Mico-Leão → Onça-Pintada
        SymbolMap["MicoLeao"] = SymbolID.Onca;
    } else if (crystals >= 8 && crystals < 12) {
        // Estado 2: Jacaré → Onça-Pintada
        SymbolMap["Jacare"] = SymbolID.Onca;
    }
    // ... etc
}

} ```

6. Outcome Builder Logic (Reverse Scripting)

6.1 Algoritmo de Decomposição

```csharp public class OutcomeBuilder {

public int[] GetReelStops(int prizeInCents, string rtpMode) {
    // Carrega reel strips da configuração RTP
    VirtualReels reels = ReelManager.GetReels(rtpMode);

    // Lista todas as combinações que resultam no prêmio
    List<int[]> validCombinations = new List<int[]>();

    for (int r1 = 0; r1 < reels[0].Count; r1++) {
        for (int r2 = 0; r2 < reels[1].Count; r2++) {
            for (int r3 = 0; r3 < reels[2].Count; r3++) {
                for (int r4 = 0; r4 < reels[3].Count; r4++) {
                    for (int r5 = 0; r5 < reels[4].Count; r5++) {
                        int payResult = CalculatePay(
                            reels[0][r1], reels[1][r2], reels[2][r3],
                            reels[3][r4], reels[4][r5]
                        );

                        if (payResult == prizeInCents) {
                            validCombinations.Add(new int[] { r1, r2, r3, r4, r5 });
                        }
                    }
                }
            }
        }
    }

    // Se nenhuma combinação exata, tenta com bonus
    if (validCombinations.Count == 0) {
        return FallbackBonusDecomposition(prizeInCents);
    }

    // Seleciona aleatoriamente uma das combinações válidas
    Random rand = new Random();
    return validCombinations[rand.Next(validCombinations.Count)];
}

private int CalculatePay(Symbol s1, Symbol s2, Symbol s3,
                         Symbol s4, Symbol s5) {
    // Implementa a tabela de pagamento
    // Verifica 1024 Ways
    int totalWin = 0;

    for (int way = 0; way < 1024; way++) {
        int[] linePositions = GetWayPositions(way);
        if (IsWinningLine(s1, s2, s3, s4, s5, linePositions)) {
            int lineWin = GetLinePayment(s1, s2, s3, s4, s5);
            totalWin += lineWin;
        }
    }

    return totalWin;
}

} ```

7. G2S/SAS Protocol Integration

7.1 Handshake Inicial

``` VLT Terminal → Lottopar Server: CONNECT_REQ { terminal_id: "000001", equipment_name: "Tesouros_da_Amazonia_01", firmware_version: "1.0.0", last_session_id: "2026040312X01" }

Lottopar Server → VLT Terminal: CONNECT_ACK { session_id: "2026040312Y01", config_version: "94", // RTP mode time_sync: 1749120000 } ```

7.2 Transmissão de Resultado

``` VLT Terminal → Lottopar: SPIN_REQUEST { session_id: "2026040312Y01", terminal_id: "000001", wager: 200, // em centavos (R$ 2,00) denomination: 1, // R$ 0,01 game_id: "01_TESOUROS_AMAZONIA", timestamp: 1749120500 }

Lottopar → VLT Terminal: SPIN_RESULT { spin_id: "SPL_20260403_000001_001", prize: 4000, // em centavos (R$ 40,00) bonus_triggered: false, crc: 0x7F2E3A1C, // Checksum de segurança timestamp: 1749120502 } ```

7.3 Auditoria e Logs

VLT → Lottopar (Diáriamente): AUDIT_REPORT { report_date: "2026-04-03", terminal_id: "000001", total_spins: 7560, coin_in: 1512000, // R$ 15.120,00 coin_out: 1422576, // R$ 14.225,76 (94% payout) ggr: 89424, // R$ 894,24 sessions: [ { session_id: "...", spins: 150, result: "balanced" }, ... ] }

8. Hardware Specifications

8.1 Requisitos Mínimos

8.2 Periféricos Obrigatórios

• Botões Físicos: Girar (grande), Aposta +/-, Máximo, Histórico
• Leitor de Cartão: Integração com programa de fidelidade
• Moedeiro/Bill Acceptor: CECM compatível
• Lockbox: Para depósito de dinheiro (segurança)

9. Markov Chain para Bonus Progression

9.1 Matriz de Transição de Estados (Free Spins)

``` Estados: [Estado_0, Estado_1, Estado_2, Estado_3, Estado_4]

Matriz de Transição (RTP 94%): E0 E1 E2 E3 E4 E0 [0.90 0.08 0.015 0.005 0.000] E1 [0.00 0.88 0.10 0.01 0.005] E2 [0.00 0.00 0.85 0.13 0.020] E3 [0.00 0.00 0.00 0.80 0.200] E4 [0.00 0.00 0.00 0.00 1.000] (Absorvente)

Interpretação: - De E0: 90% chance de permanecer (sem coleta), 8% chance de ir para E1 - De E3: 20% chance de atingir o Estado Final (Grande Win) ```

9.2 Simulação de Ciclo

```csharp public class MarkovBonusEngine { private double[][] transitionMatrix = LoadTransitionMatrix(rtpMode); private int currentState = 0; // Começa no Estado 0

public int GetNextState() {
    Random rand = new Random();
    double roll = rand.NextDouble();  // 0.0 to 1.0

    double cumulative = 0.0;
    for (int nextState = 0; nextState < 5; nextState++) {
        cumulative += transitionMatrix[currentState][nextState];
        if (roll <= cumulative) {
            currentState = nextState;
            return nextState;
        }
    }
    return currentState;  // Fallback
}

public void SimulateFreeSpin() {
    int nextState = GetNextState();
    if (nextState >= 1) {
        crystalCollected++;
        ApplySymbolTransformation(nextState);
    }
    // Atualiza UI
}

} ```

10. Near-Miss Engineering

10.1 Estratégia de Visualização

Para aumentar a retenção sem alterar RTP, implementamos "near misses" psicologicamente efetivos:

Scatter (Moeda) Near Miss: ``` Rolo 5 Stops: 00: Onça (Top) 01: Blank 02: Blank 03: Moeda (Scatter) ← Colocado estrategicamente 04: Blank ...

RTP 97%: Moeda é visível em ~40% dos giros (logo acima/abaixo da linha) RTP 90%: Moeda é visível em ~15% dos giros (mais "oculta") ```

Wild Near Miss: Rolo 2-4: Wilds aparecem frequentemente logo após a linha de pagamento Visual: Jogador vê "Wild passou perto" Efeito: Aumenta sensação de "quase vitória" sem alterar prêmios reais

10.2 Frequência de Near Miss

• Meta: ~35% de giros mostram pelo menos um símbolo de prêmio alto fora da linha
• RTP 97%: Aumenta frequência de near miss em 40%
• RTP 90%: Reduz frequência em 20%

11. C# Code Architecture References

11.1 DLL Principal: VltCore.dll

```csharp namespace Oktop.VLT.Core { public class VltEngine { private PoolFiniteClient poolClient; private ReelEngine reelEngine; private OutcomeBuilder outcomeBuilder; private GameStateMachine stateMachine;

    public void InitializeGame(string gameId, string rtpMode) {
        poolClient = new PoolFiniteClient("https://lottopar.api");
        reelEngine = new ReelEngine(gameId);
        outcomeBuilder = new OutcomeBuilder(rtpMode);
        stateMachine = new GameStateMachine();
    }

    public void OnSpinClicked(decimal bet) {
        if (!stateMachine.CanSpin()) return;

        // 1. Requisita outcome
        Outcome outcome = poolClient.RequestSpin(bet);

        // 2. Constrói combinação visual
        int[] reelStops = outcomeBuilder.GetReelStops(outcome);

        // 3. Executa transição visual
        reelEngine.SpinReels(reelStops);

        // 4. Processa result
        stateMachine.ProcessOutcome(outcome);
    }
}

} ```

11.2 PoolEngine.dll

```csharp public class PoolFiniteClient { private HttpClient client; private string apiUrl;

public Outcome RequestSpin(decimal bet) {
    SpinRequest req = new SpinRequest {
        TerminalId = GetTerminalId(),
        Bet = (int)(bet * 100),  // Converte para centavos
        Timestamp = DateTime.UtcNow
    };

    HttpResponse response = client.Post($"{apiUrl}/spin", req);
    Outcome outcome = Outcome.FromJson(response.Body);

    // Verifica integridade
    if (!ValidateCRC(outcome)) {
        throw new SecurityException("Invalid CRC");
    }

    return outcome;
}

} ```

11.3 OutcomeBuilder.dll

```csharp public class OutcomeBuilder { private VirtualReels reels;

public int[] GetReelStops(Outcome outcome) {
    // Implementação conforme descrito na Seção 6
    List<int[]> validStops = FindAllValidStops(outcome.PrizeInCents);
    return validStops[new Random().Next(validStops.Count)];
}

private List<int[]> FindAllValidStops(int targetPrize) {
    // Busca exaustiva de todas as combinações
    List<int[]> result = new List<int[]>();

    for (int r1 = 0; r1 < reels[0].Length; r1++) {
        for (int r2 = 0; r2 < reels[1].Length; r2++) {
            for (int r3 = 0; r3 < reels[2].Length; r3++) {
                for (int r4 = 0; r4 < reels[3].Length; r4++) {
                    for (int r5 = 0; r5 < reels[4].Length; r5++) {
                        if (CalculatePay(r1, r2, r3, r4, r5) == targetPrize) {
                            result.Add(new int[] { r1, r2, r3, r4, r5 });
                        }
                    }
                }
            }
        }
    }

    return result;
}

} ```

12. Segurança e Integridade

12.1 Proteção de Dados

• Encriptação: AES-256 para comunicação com servidor
• Hash: SHA-256 para integridade de reel strips
• Token: JWT com expiração de 5 minutos para sessões

12.2 Proteção de Código

• Code Obfuscation: Usar confusores comerciais (ex: Dotfuscator)
• Checksums: CRC-32 de DLLs críticas verificado na inicialização
• Memory Protection: Não armazenar valores de prêmios em texto plano

13. Testes e Validação

13.1 Plano de Testes

1. Testes de RTP: 500.000 spins em 90%, 94%, 97%
2. Testes de Bônus: Frequência de Free Spins dentro de margem de ±2%
3. Testes de Near Miss: Validar visibilidade de símbolos
4. Testes de Segurança: Tentar manipular outcomes via socket sniffing

13.2 Metricas de Convergência

• Objetivo: RTP converge dentro de ±1% em 100.000 giros
• Frequência de Bônus: 1/118 ±3 em 10.000 giros

14. Deployment Checklist

• [ ] VltCore.dll assinada e certificada
• [ ] Reel strips encodificadas e testadas
• [ ] G2S/SAS protocols integrados e testados
• [ ] Lottopar auditoria concluída
• [ ] Documentação técnica aprovada
• [ ] Hardware configurado e testado
• [ ] Network connectivity validada
• [ ] Backup e disaster recovery planejados

Documento Assinado Digitalmente por: Gerado em: 2026-04-03 Versão: 1.0 Status: Pronto para Testes de QA

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.