22 - CIGANA DA SORTE

Technical Design Document (TDD)

Referência: Lucky Lady's Charm (Novomatic) Arquitetura: Lottopar Core (Pool Finito) Status: Design Finalizado Data: 2026-04-03

1. VISÃO GERAL TÉCNICA

Este documento especifica a implementação técnica do Cigana da Sorte com foco em: - Gestão de multiplicadores compostos (2x Wild + 3x Bônus = 6x) - Reel strip otimizado para 10 linhas - Tease system (batida de coração com 2 Scatters) - Sincronismo de audio com game events - Integração VltCore.dll

2. REEL STRIPS E CONFIGURAÇÃO

Configuração Geral

• Rolos: 5
• Posições por Rolo: 40 (múltiplo de 10 para linhas)
• Full Cycle: 40^5 = 102,400,000 combinações

Reel Strip Mapping

Reel 1 (Esquerda - Wild Focus)

Posição | Símbolo | Frequência | Tipo --------|------------|------------|------- 0-3 | Wild | 4x | Normal 4-6 | Lucky | 3x | High 7-9 | Clover | 3x | High 10-12 | Horseshoe | 3x | High 13-15 | A | 3x | Low 16-18 | K | 3x | Low 19-21 | Q | 3x | Low 22-24 | J | 3x | Low 25-27 | 10 | 3x | Low 28-30 | 9 | 3x | Low 31-33 | Scatter | 3x | Bonus Trigger 34-39 | [Reserved] | 6x | Buffer

Proporção: Wild 10%, Scatter 7.5%, High 22.5%, Low 60%

Reel 2, 3, 4 (Universais)

Idêntico ao Reel 1 para balanceamento de distribuição

Reel 5 (Direita - Wild Focus)

Idêntico ao Reel 1 para correlação visual direita-esquerda

Probabilidades Derivadas

3. ALGORITMO DE FATORAÇÃO REVERSA (REVERSE MATH)

Problema: Multiplicadores Compostos

O Pool Finito devolve um TicketWin (ex: R$ 54,00). O OutcomeBuilder deve encaixar este valor nos multiplicadores: - 2x (Wild) - 3x (Free Spins) - 6x (Wild + FS combinado)

Solução: Algoritmo em Cascata

```csharp public decimal FindOptimalPayline(decimal targetWin, decimal betPerLine) {

// Fase 1: Tentativa de 6x (Wild + Bônus)
decimal basePay6x = targetWin / 6m;
if (IsValidPaytableValue(basePay6x)) {
    return basePay6x; // Usar Wild no Bônus
}

// Fase 2: Tentativa de 3x (Bônus sem Wild)
decimal basePay3x = targetWin / 3m;
if (IsValidPaytableValue(basePay3x)) {
    return basePay3x; // Usar Bônus sem Wild
}

// Fase 3: Tentativa de 2x (Wild no Base)
decimal basePay2x = targetWin / 2m;
if (IsValidPaytableValue(basePay2x)) {
    return basePay2x; // Usar Wild no Base Game
}

// Fase 4: Sem multiplicador
if (IsValidPaytableValue(targetWin)) {
    return targetWin; // Pagar direto
}

// Fase 5: Fallback - Ajuste fino com resíduo
return ApplyResidueCorrection(targetWin);

}

private bool IsValidPaytableValue(decimal value) { // Verificar se existe na tabela de pagamentos var validEntries = paytable.Where(x => Math.Abs(x - value) < 0.01m).ToList(); return validEntries.Count > 0; } ```

Tabela de Paylines Otimizada

A tabela deve conter valores que sejam divisíveis por 1, 2, 3 e 6:

Símbolo | 5x | 4x | 3x | Nota ---------|-------|------|-----|----- Lucky | 600 | 120 | 30 | Divisível por 6 Clover | 540 | 108 | 27 | Divisível por 6 Horse. | 480 | 96 | 24 | Divisível por 6 A | 300 | 60 | 15 | Divisível por 6 K | 240 | 48 | 12 | Divisível por 6 Q | 180 | 36 | 9 | Divisível por 6 J | 120 | 24 | 6 | Divisível por 6 10 | 90 | 18 | 4.5 | Divisível por 3 9 | 60 | 12 | 3 | Divisível por 3

Regra de Design: Todos os valores devem ser múltiplos de 6 quando possível.

4. CÁLCULO DE MULTIPLICADORES

Matriz de Multiplicação

``` Base Game Multiplicador: ┌─────────────────────────────┐ │ Nenhum Wild → 1x │ │ Com Wild → 2x │ └─────────────────────────────┘

Free Spin Multiplicador: ┌─────────────────────────────┐ │ Nenhum Wild → 3x │ │ Com Wild → 2x × 3x = 6x │ └─────────────────────────────┘ ```

Exemplo Completo de Cálculo

``` Aposta: R$ 6,00 (R$ 0,60 por linha × 10 linhas) Combinação encontrada: [Lucky, Lucky, Lucky, Lucky, Wild]

Paytable lookup: - Lucky (4x) = 120x valor base - Com Wild = 120x × 2 = 240x

Ganho total: 240x × R$ 0,60 = R$ 144,00

Se em Free Spins: - Ganho base: 120x × R$ 0,60 = R$ 72,00 - Com multiplicador bônus (3x): R$ 72,00 × 3 = R$ 216,00 - Com Wild adicional (2x): R$ 72,00 × 2 × 3 = R$ 432,00 ```

5. SISTEMA TEASE (BATIDA DE CORAÇÃO)

Detecção de 2 Scatters

```csharp public class TeaseDetectionSystem {

public bool DetectTease(Symbol[,] grid) {
    int scatterCount = 0;
    List<Vector2> scatterPositions = new();

    foreach (var pos in grid.GetAllPositions()) {
        if (grid[pos].IsScatter) {
            scatterCount++;
            scatterPositions.Add(pos);
        }
    }

    return scatterCount == 2; // Exatamente 2 (não 3+)
}

public void TriggerTease(Symbol[,] grid) {
    // 1. Pausar animação de reels
    reelController.Pause();

    // 2. Carregar som pré-buffer (crítico para latência)
    audioManager.PreloadTease();

    // 3. Fade escuro avermelhado
    screenFade.To(new Color(0.5f, 0, 0), 0.5f);

    // 4. Iniciar loop de batida de coração
    audioManager.PlayTease();

    // Duração: 1.5 segundos
    // Efeito: "dum-dum-dum" acelerado

    // 5. Esperar 1.5s
    yield return new WaitForSeconds(1.5f);

    // 6. Restaurar visual normal
    screenFade.To(Color.white, 0.3f);

    // 7. Continuar reels normalmente
    reelController.Resume();
}

} ```

Audio Latency & Pre-Load

Problema crítico: Som de Tease deve tocar instantaneamente ao detectar 2 Scatters. Latência = ruim.

Solução: 1. O JSON do Pool já traz flag: tease_detected: true 2. Unity carrega arquivo de áudio na memória RAM (buffer) 3. Ao receber outcome, toca de forma síncrone (latência < 10ms)

```csharp public class AudioPreloader {

private Dictionary<string, AudioClip> buffers = new();

public void Initialize() {
    // Carregar sons críticos no boot
    buffers["tease"] = Resources.Load<AudioClip>("Sounds/Tease");
    buffers["freeSpinTrigger"] = Resources.Load<AudioClip>("Sounds/FreeSpinActivated");
    buffers["winChime"] = Resources.Load<AudioClip>("Sounds/WinChime");
}

public void PlayTease() {
    audioSource.PlayOneShot(buffers["tease"]); // Latência < 10ms
}

} ```

6. GERENCIAMENTO DE FREE SPINS

Estrutura de Sessão

```csharp public class FreeSpinSession { public int InitialSpins { get; set; } = 15; public int CurrentSpins { get; set; } public decimal TotalAccumulated { get; set; } = 0; public int RetriggerCount { get; set; } = 0; public const int MAX_RETRIGGERS = 3;

public void ProcessSpin(decimal spinResult) {
    AccumulateWin(spinResult);
    CurrentSpins--;

    // Detectar retrigger
    if (DetectRetrigger()) {
        if (RetriggerCount < MAX_RETRIGGERS) {
            CurrentSpins += 15;
            RetriggerCount++;
        }
    }
}

private void AccumulateWin(decimal result) {
    TotalAccumulated += result;
}

private bool DetectRetrigger() {
    // Verificar se Pool sinalizou retrigger
    return JsonPayload.ContainsKey("retrigger_flag");
}

} ```

Pool Request com Flags

json { "round_id": "CIGANA_555", "round_type": "BASE_GAME", "total_bet": 6.00, "bet_per_line": 0.60, "total_ticket_win": 54.00, "multiplicand": { "wild_active": true, "multiplier_2x": true, "bonus_active": false, "effective_multiplier": 2.0 }, "tease_detected": false, "hash": "xyz789abc", "timestamp": "2026-04-03T14:25:10Z" }

Pool Request para Free Spin com Retrigger

json { "round_id": "CIGANA_556", "round_type": "FREE_SPIN", "spin_number": 7, "total_bet": 6.00, "bet_per_line": 0.60, "total_ticket_win": 216.00, "multiplicand": { "wild_active": true, "bonus_active": true, "multiplier_2x": true, "multiplier_3x": true, "effective_multiplier": 6.0 }, "retrigger_flag": true, "additional_spins": 15, "hash": "abc123xyz", "timestamp": "2026-04-03T14:25:15Z" }

7. PATTERN MATCHING PARA 10 LINHAS

Definição de Linhas

```csharp private int[][] paylines = new int[][] { new int[] {0, 0, 0, 0, 0}, // Linha 1: Topo new int[] {1, 1, 1, 1, 1}, // Linha 2: Meio new int[] {2, 2, 2, 2, 2}, // Linha 3: Fundo

new int[] {0, 1, 1, 1, 0}, // Linha 4: V invertida
new int[] {2, 1, 1, 1, 2}, // Linha 5: V normal

new int[] {0, 0, 1, 0, 0}, // Linha 6: Topo com cume
new int[] {2, 2, 1, 2, 2}, // Linha 7: Fundo com cume

new int[] {0, 1, 2, 1, 0}, // Linha 8: Zig-zag descendo
new int[] {2, 1, 0, 1, 2}, // Linha 9: Zig-zag subindo

new int[] {1, 0, 1, 0, 1}  // Linha 10: Alternada

}; ```

Algoritmo de Verificação

```csharp public decimal CheckPayline(int[] lineConfig, Symbol[,] grid, decimal betPerLine) {

Symbol firstSymbol = grid[lineConfig[0], 0];

// Rejeitar linhas começadas por Scatter
if (firstSymbol.IsScatter) return 0;

int matches = 0;
decimal wildMultiplier = 1m;

for (int reel = 0; reel < 5; reel++) {
    Symbol current = grid[lineConfig[reel], reel];

    // Detectar Wild
    if (current.IsWild) {
        wildMultiplier = 2m;
        current = firstSymbol; // Substitui
    }

    if (current == firstSymbol) {
        matches++;
    } else {
        break; // Combinação quebrada
    }
}

if (matches < 3) return 0; // Mínimo 3 símbolos

decimal basePayment = GetPaytableValue(firstSymbol, matches);
decimal wildcardPayment = basePayment * wildMultiplier;
decimal lineWin = wildcardPayment * betPerLine;

return lineWin;

} ```

8. VALIDAÇÃO PRÉ-APRESENTAÇÃO

Server-Side Validation

```csharp public bool ValidateOutcome(Outcome outcome) {

// 1. Verificação de hash
string computed = SHA256(outcome.rawData);
if (computed != outcome.hash) {
    LogError("Hash validation failed");
    return false;
}

// 2. Verificação de RTP
decimal rtp = outcome.totalWin / outcome.totalBet;
if (rtp < 0.92m || rtp > 1.98m) { // 92% - 198%
    LogError($"RTP out of bounds: {rtp}");
    return false;
}

// 3. Verificação de Multiplicadores
if (outcome.wildActive && outcome.bonusActive) {
    if (outcome.effectiveMultiplier != 6m) {
        LogError("Multiplier mismatch for Wild+Bonus");
        return false;
    }
}

// 4. Recalcular ganho a partir da grade
decimal recalc = RecalculateWinFromGrid(outcome.grid);
if (Math.Abs(recalc - outcome.totalWin) > 0.01m) {
    LogError($"Win calculation mismatch");
    return false;
}

// 5. Validar Scatters
int scatterCount = outcome.grid.CountScatters();
if (scatterCount > 5) {
    LogError("Excessive scatter count");
    return false;
}

return true;

} ```

9. SINCRONISMO CRÍTICO

Animação de Spin com Audio Ducking

```csharp public class SpinController : MonoBehaviour {

public IEnumerator ExecuteSpin(Outcome outcome) {

    // 1. Receber outcome do Pool
    ValidateOutcome(outcome);

    // 2. Iniciar animação de rolos
    StartCoroutine(AnimateReels(3.5f));

    // 3. Detectar Tease
    if (outcome.teaseDetected) {
        yield return new WaitForSeconds(1.5f); // Deixar rolos girarem

        // 4. Pausar rolos
        reelController.Pause();

        // 5. Iniciar Tease com Audio Ducking
        audioManager.DuckMusic(0.6f); // Reduz música para 60%
        audioManager.PlayTease();

        yield return new WaitForSeconds(1.5f);

        // 6. Restaurar
        audioManager.UnDuck(0.3f);
        reelController.Resume();

        yield return new WaitForSeconds(2.0f); // Continuar giro
    }

    // 7. Parar rolos nos índices do outcome
    for (int reel = 0; reel < 5; reel++) {
        StopReelAtIndex(reel, outcome.reel_stops[reel], 0.4f);
    }

    yield return new WaitForSeconds(0.5f);

    // 8. Apresentação de Ganhos
    StartCoroutine(PresentWins(outcome));
}

private void StopReelAtIndex(int reel, int index, float duration) {
    float targetRotation = index * 24f; // 360 / 15 posições = 24°
    DOTween.To(
        () => reels[reel].rotation.z,
        x => reels[reel].rotation = new Vector3(0, 0, x),
        targetRotation,
        duration
    ).SetEase(Ease.OutQuart); // Frenagem suave
}

} ```

10. RTP BANKING (RESÍDUO)

Gestão de Resíduos Decimais

```csharp public class ResidueWallet {

private decimal balance = 0m;
private const decimal MIN_RESIDUE = 0.01m; // 1 centavo

public decimal ApplyResidue(decimal expectedWin, decimal achievedWin) {

    decimal difference = expectedWin - achievedWin;

    if (difference > 0) {
        // Sobra: guardar para próxima rodada
        balance += difference;
    } else if (difference < 0) {
        // Déficit: tirar do banco se tiver
        decimal needed = Math.Abs(difference);
        if (balance >= needed) {
            balance -= needed;
            return achievedWin + needed;
        }
    }

    // Se banco vazio, retornar ganho ajustado
    return achievedWin;
}

public void FlushIfPossible() {
    // Se banco atingiu R$ 0,01, devolver ao jogador
    if (balance >= MIN_RESIDUE) {
        player.Balance += balance;
        LogTransaction($"RESIDUE_FLUSH: {balance}");
        balance = 0;
    }
}

} ```

11. JSON PAYLOAD EXEMPLO COMPLETO

Free Spin com Retrigger

json { "game_id": 22, "round_id": "CIGANA_999", "round_type": "FREE_SPIN", "spin_number": 3, "total_bet": 6.00, "bet_per_line": 0.60, "lines": 10, "expected_win": 216.00, "actual_win": 216.00, "game_state_before": { "balance": 150.00, "spins_remaining": 5 }, "game_state_after": { "balance": 366.00, "spins_remaining": 20 }, "reel_stops": [0, 4, 2, 3, 1], "grid": [ ["Lucky", "Lucky", "Lucky", "Clover", "Lucky"], ["Clover", "Wild", "Wild", "Lucky", "Horseshoe"], ["Horseshoe", "A", "Clover", "Clover", "A"] ], "winning_lines": [1, 2, 3, 5], "individual_line_wins": { "line_1": 54.00, "line_2": 54.00, "line_3": 54.00, "line_5": 54.00 }, "multiplicands": { "wild_active": true, "bonus_active": true, "wild_multiplier": 2.0, "bonus_multiplier": 3.0, "effective_multiplier": 6.0 }, "retrigger": { "detected": true, "scatter_count": 3, "additional_spins": 15, "new_total_spins": 20 }, "tease_detected": false, "audio_cues": ["freeSpinRetrigger", "chime"], "presentation_type": "RETRIGGER", "hash": "d4c3b2a1f9e8d7c6b5a4f3e2d1c0b9a8", "timestamp": "2026-04-03T14:26:45.123Z", "session_id": "sess_abc123xyz789" }

12. ESPECIFICAÇÕES DE HARDWARE

Requisitos Mínimos

• Processador: Intel Core i5 (6ª gen) ou equivalente
• RAM: 4GB DDR4
• SSD: 256GB
• GPU: NVIDIA GeForce GTX 750+
• Display: 24" @ 60Hz, 1920x1080
• Áudio: Sistema 5.1 (obrigatório)

Requisitos de Rede

• Protocolo: Ethernet Gigabit
• Latência: < 100ms (requisição para TicketWin)
• Sincronização: NTP obrigatória
• Fallback: Cache local por 4 horas

13. PROTOCOLO SAS/G2S

Configuração

``` Machine Address: [Conforme instalação] Game Number: 22 Game Version: 1.0

Fluxo de Auditoria: 1. SPIN_INITIATED → Log SAS imediato 2. TICKET_GENERATED → ID único 3. OUTCOME_PRESENTED → Ganho exibido 4. TICKET_REDEEMED → Saldo atualizado ```

14. TESTES E VALIDAÇÃO

Test Case 1: Retrigger

``` Input: Free Spin com 3 Scatters na tela Expected: +15 Giros, Pop-up "Ganhou +15 Giros!"

Verificações: 1. RetriggerCount incrementa 2. Giros atualizados corretamente 3. Som de sino toca 4. Madame Sara pisca 5. Multiplicador continua 6x (se Wild presente) ```

Test Case 2: Tease System

``` Input: Outcome com exatamente 2 Scatters Expected: Audio Tease (batida de coração), screen fade

Verificações: 1. Rolos pausam corretamente 2. Batida toca sem latência (<10ms) 3. Música faz ducking para 60% 4. Fade avermelhado ativa 5. Após 1.5s, restaura tudo normalmente ```

Test Case 3: Multiplicador Composto

``` Input: Wild + Free Spin (Bônus) Expected: Ganho × 2 × 3 = 6x

Exemplo: - Base payout: Lucky (4x) = 80x - Com Wild: 80x × 2 = 160x - No Bônus: 160x × 3 = 480x - Final: 480x × R$ 0,60 = R$ 288,00 ```

Stress Test (1M giros)

Métricas: - RTP: 94% ± 2% - Hit Frequency: 24% ± 1% - Average Spin Duration: 4.2s - Memory Leak: None (monitored) - Tease Accuracy: 100% (quando 2 Scatters)

15. CONFORMIDADE LOTTOPAR

Documentação Requerida

• ✓ Reel Strip Map com probabilidades
• ✓ Paytable completa (com multiplicadores)
• ✓ Algoritmo de Reverse Math
• ✓ RTP Certificado (94%)
• ✓ Teste de Aleatoriedade (1M giros)
• ✓ Hardware Specification
• ✓ SAS Audit Trail
• ✓ Tease System Documentation

Documento Finalizado: 03/04/2026 Versão: 1.0 - Draft Final Certificação: Pendente Lottopar

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.