Technical Design Document (TDD) - Faraó do Brasil

Projeto: 04 - Faraó do Brasil Versão: 1.0 Data: 2026-04-03

1. Expanding Symbol Engine

```csharp public class ExpandingSymbolEngine { private Symbol selectedExpansionSymbol; private int[] reelStops;

public void TriggerFreeSpins(int[] triggerStops) {
    // 1. Seleciona símbolo expansivo
    selectedExpansionSymbol = SelectExpansionSymbol();
    ShowSymbolSelectionAnimation(selectedExpansionSymbol);

    // 2. Inicia 10 Giros Grátis com este símbolo fixo
    for (int i = 0; i < 10; i++) {
        ExecuteFreeSpinWithExpansion();
    }
}

private Symbol SelectExpansionSymbol() {
    CoinFlip rand = new CoinFlip();
    double roll = rand.NextDouble();

    // RTP 94% weights:
    if (roll < 0.025) return Symbol.Farao;        // 2,5%
    if (roll < 0.115) return Symbol.Escaravelho;  // 9%
    if (roll < 0.265) return Symbol.Estátua;      // 15%
    if (roll < 0.595) return Symbol.AK;           // 33%
    return Symbol.QJ10;                            // 40,5%
}

public void ExecuteFreeSpinWithExpansion() {
    // 1. Faz spin normal
    Outcome freeSpinOutcome = PoolEngine.RequestFreeSpin();
    int[] stops = OutcomeBuilder.GetReelStops(freeSpinOutcome.Prize);

    // 2. Conta ocorrências do símbolo especial
    int symbolCount = CountSymbol(stops, selectedExpansionSymbol);

    if (symbolCount >= GetMinimumForExpansion(selectedExpansionSymbol)) {
        // 3. Executa expansão
        ExpandSymbols(selectedExpansionSymbol);
        int expandedWin = CalculateExpandedPayment(symbolCount);

        // 4. Verifica retrigger
        if (HasRetrigger(stops)) {
            freeSpinsRemaining += 10;
            PlayRetriggerAnimation();
        }
    }
}

private int GetMinimumForExpansion(Symbol symbol) {
    // Altos: 2+, Baixos: 3+
    return (symbol == Symbol.Farao || symbol == Symbol.Escaravelho) ? 2 : 3;
}

private void ExpandSymbols(Symbol symbol) {
    // Desenha o símbolo preenchendo inteiro a bobina
    for (int reel = 0; reel < 5; reel++) {
        if (GetReelSymbol(reelStops, reel) == symbol) {
            VisualEngine.ExpandReelSymbol(reel, symbol);
        }
    }
}

private int CalculateExpandedPayment(int symbolCount) {
    // 10 linhas × valor do símbolo
    int basePayment = GetSymbolPayment(selectedExpansionSymbol);
    return 10 * basePayment;
}

} ```

2. Outcome Builder para 10 Linhas

```csharp public class OutcomeBuilder10Lines {

public int[] BuildExpandingOutcome(int targetPrize, VirtualReels reels) {
    // Encontra paradas que permitem expansão para atingir targetPrize

    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 normalWin = Calculate10LinesPay(r1, r2, r3, r4, r5);

                        // Verifica se com expansão atinge alvo
                        int expandedWin = SimulateExpansion(
                            r1, r2, r3, r4, r5,
                            selectedExpansionSymbol
                        );

                        if (expandedWin == targetPrize) {
                            return new[] { r1, r2, r3, r4, r5 };
                        }
                    }
                }
            }
        }
    }
    return null;  // Fallback
}

private int Calculate10LinesPay(int r1, int r2, int r3, int r4, int r5) {
    int totalWin = 0;

    // Percorre as 10 linhas
    for (int line = 0; line < 10; line++) {
        int[] linePositions = GetLinePositions(line);
        Symbol s1 = reels[0][r1].GetSymbol(linePositions[0]);
        Symbol s2 = reels[1][r2].GetSymbol(linePositions[1]);
        // ... etc

        if (IsWinningLine(s1, s2, s3, s4, s5)) {
            totalWin += GetLinePayment(s1, s2, s3, s4, s5);
        }
    }

    return totalWin;
}

private int SimulateExpansion(int r1, int r2, int r3, int r4, int r5, Symbol expSymbol) {
    // Simula pagamento COM expansão
    int baseWin = Calculate10LinesPay(r1, r2, r3, r4, r5);
    int expandedWin = baseWin;

    // Adiciona ganho da expansão
    int expCount = CountSymbolInStops(r1, r2, r3, r4, r5, expSymbol);
    if (expCount >= GetMinimum(expSymbol)) {
        expandedWin = 10 * GetSymbolValue(expSymbol);
    }

    return expandedWin;
}

} ```

3. Reel Strips Configuration (10 Linhas)

Paradas Padrão (RTP 94%): ``` Rolo 1 (32 paradas):

[8-31]: Cartas baixas + Blanks ```

RTP Adjustment: - RTP 90%: Reduz Livro para 0 ou 1 por rolo; Faraó apenas em Rolo 1 - RTP 97%: Aumenta Livro para 2 por rolo; Faraó em rolos 1 e 5

4. Retrigger Probability Engine

```csharp public class RetriggerEngine { private string rtpMode;

public bool CheckRetrigger(int[] reelStops) {
    int scatterCount = CountScatters(reelStops);

    if (scatterCount >= 3) {
        double retriggerChance = rtpMode == "97" ? 0.0833 : 0.0454;
        return new Random().NextDouble() < retriggerChance;
    }
    return false;
}

// RTP 97%: 1/12 = 0.0833
// RTP 90%: 1/22 = 0.0454

} ```

5. Near Miss Strategy

csharp public void ApplyNearMissStrategy(VirtualReels reels, string rtpMode) { if (rtpMode == "97") { // Coloca Faraó logo depois de Livro para criar tensão for (int reel = 0; reel < 5; reel++) { for (int i = 0; i < reels[reel].Count; i++) { if (reels[reel][i] == Symbol.Livro) { // Próxima parada tem alta chance de Faraó if (i < reels[reel].Count - 1) { reels[reel][i + 1] = Symbol.Farao; } } } } } }

6. G2S Protocol (Free Spins)

Free Spin Request: json { "terminal_id": "000004", "parent_spin_id": "SP4_20260403_000004", "free_spin_number": 1, "selected_symbol": "Farao", "retrigger_count": 0 }

Response: json { "free_spin_id": "FS1_000004", "prize": 50000, // 5.000x a aposta "expansion_count": 5, // 5 Faraós na tela "retrigger": false, "final_win": 50000 }

7. High Volatility State Machine

```csharp enum VolatilityState { Dry, // Hit frequency baixa Tension, // 2-3 Livros visíveis Bonus, // Free Spins ativado Expansion, // Símbolo expandindo Triumph // Prêmio massivo entregue }

// Ciclo típico: Dry (15-20 giros) → Tension (2 giros) → Bonus → Triumph ```

8. Audio Sync for Expansion

```csharp public void PlayExpansionAudio(Symbol symbol) { AudioManager.PlayEffect("stone_movement.wav"); AudioManager.PlayEffect("temple_bell.wav", volume: 0.7);

if (symbol == Symbol.Farao) {
    AudioManager.PlayOrchestraStab();  // Épico
}

} ```

9. Testing Checklist

• [ ] Validar frequência de Livro (3+) em 250k spins
• [ ] Testar cada símbolo expansivo isoladamente
• [ ] Verificar retrigger em 50k spins de bônus
• [ ] Validar Max Win (5.000x) é alcançável
• [ ] Testar near miss visibilidade por RTP mode

10. Performance & Limits

Status: Pronto para Lab Testing Versão: 1.0

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.