Technical Design Document (TDD) - Cangaço Luck

Projeto: 03 - Cangaço Luck Versão: 1.0 Data: 2026-04-03

1. Hold & Spin Engine Architecture

```csharp public class HoldAndSpinEngine { private List activeCoinsMoedas; private int gridPositions = 15; // 3x5 grid private int respinsRemaining = 3;

public void OnHoldAndSpinTriggered(int[] reelStops) {
    // Extrai todas as Moedas dos rolos
    activeCoinsMoedas = ExtractCoins(reelStops);

    if (activeCoinsMoedas.Count >= 6) {
        InitializeGrid();
        ShowHoldAndSpinScreen();
    }
}

public void OnRespin() {
    respinsRemaining--;

    int newCoinCount = SimulateRespin();
    if (newCoinCount > 0) {
        respinsRemaining = 3;  // Reset
        activeCoinsMoedas.AddRange(newCoinCount);
    }

    if (respinsRemaining == 0 || activeCoinsMoedas.Count == 15) {
        CalculateTotalWin();
        ExitHoldAndSpin();
    }
}

private int SimulateRespin() {
    // Requisita novo outcome do servidor para 1 spin
    Outcome respin = PoolFiniteClient.RequestRespin();
    return CountCoinsInOutcome(respin);
}

} ```

2. Weighted Distribution of Coins

```csharp public class CoinWeightEngine { private Dictionary rtpWeights = new Dictionary();

public CoinWeightEngine(string rtpMode) {
    if (rtpMode == "94") {
        rtpWeights[1] = 0.30;   // 1x-3x: 30%
        rtpWeights[5] = 0.35;   // 5x-10x: 35%
        rtpWeights[20] = 0.28;  // 20x-50x: 28%
        rtpWeights[100] = 0.05; // Mini+: 5%
    }
}

public int GenerateCoinValue() {
    Random rand = new Random();
    double roll = rand.NextDouble();
    double cumulative = 0;

    foreach (var kvp in rtpWeights) {
        cumulative += kvp.Value;
        if (roll <= cumulative) {
            return PickValueInRange(kvp.Key);
        }
    }
    return 1;  // Fallback
}

private int PickValueInRange(int baseValue) {
    // Para 1: retorna 1-3
    // Para 5: retorna 5-10
    // Etc.
    Random rand = new Random();
    return baseValue + rand.Next(0, 4);
}

} ```

3. Outcome Builder para Hold & Spin

```csharp public int[] BuildHoldAndSpinOutcome(int targetPrize, VirtualReels reels, string rtpMode) { // Encontra todas as paradas que geram 6+ Moedas List validCombinations = new List();

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 coinCount = CountCoins(reels, r1, r2, r3, r4, r5);
                    if (coinCount >= 6) {
                        // Gera composição de moedas que soma targetPrize
                        var coinComposition = DecomposeIntoCoins(targetPrize, coinCount, rtpMode);
                        if (coinComposition != null) {
                            validCombinations.Add(new int[] { r1, r2, r3, r4, r5 });
                        }
                    }
                }
            }
        }
    }
}

return validCombinations[new Random().Next(validCombinations.Count)];

}

private List DecomposeIntoCoins(int targetTotal, int coinCount, string rtpMode) { // Distribui targetTotal entre coinCount moedas // Exemplo: 5.000 centavos (50x) em 8 moedas // Resultado: [100, 200, 150, 500, 800, 1000, 1000, 250]

CoinWeightEngine weightEngine = new CoinWeightEngine(rtpMode);
List<int> coins = new List<int>();

for (int i = 0; i < coinCount; i++) {
    coins.Add(weightEngine.GenerateCoinValue());
}

// Ajusta a última moeda para acertar o total
int current = coins.Sum();
coins[coins.Count - 1] += (targetTotal - current);

return coins;

} ```

4. Reel Strips (50 Linhas)

Parada Estratégica (RTP 94%)

Rolo 2 Exemplo: Index 00-04: Moeda (zona de coleta) Index 05-08: Wild Index 09-14: Cangaceiro (agrupado) Index 15-44: Cartas baixas (preenchimento) Index 45-49: Moeda novamente (near miss)

Dynamic Adjustment

• RTP 90%: Moedas em indices espaçados
• RTP 97%: Moedas agrupadas próximas (aumenta "pote cheio" visualmente)

5. Markov Chain for Respins

``` Estados: Nenhuma Nova Moeda | 1 Nova Moeda | 2+ Novas Moedas

Matriz (RTP 94%): Nenhuma Uma Duas Nenhuma [0.70 0.20 0.10] Uma [0.00 0.75 0.25] Duas [0.00 0.00 1.00]

Interpretação: - 70% de chance: nenhuma nova moeda (respin count diminui) - 20% de chance: 1 nova moeda (respin count reseta) - 10% de chance: bônus visual (2 moedas ao mesmo tempo) ```

6. Grand Jackpot Mechanics

```csharp public class GrandJackpotEngine { private decimal jackpotAccumulation = 50.00m; // Começa em R$ 50

public void OnSpinCompleted(decimal bet) {
    // 1% de cada aposta vai para o Grand
    jackpotAccumulation += (bet * 0.01m);
}

public bool CheckGrandTrigger() {
    // Triggered somente ao completar 15/15 no Hold & Spin
    // Probabilidade: 1 em 50.000 spins
    Random rand = new Random();
    return rand.Next(50000) == 0;
}

public void DeliverGrand(int[] reelStops) {
    if (CheckGrandTrigger()) {
        ShowGrandJackpotAnimation();
        Player.Balance += jackpotAccumulation;
        jackpotAccumulation = 50.00m;  // Reset
    }
}

} ```

7. Respin Simulation Logic

```csharp public class RespinSimulation {

public RespinResult SimulateNextRespin() {
    // 1. Requisita novo spin do servidor
    Outcome respinOutcome = PoolEngine.FetchRespin();

    // 2. Obtém paradas de rolos
    int[] stops = OutcomeBuilder.GetReelStops(respinOutcome.Prize);

    // 3. Conta Moedas
    int coinCount = CountCoins(stops);

    // 4. Atualiza UI
    return new RespinResult {
        CoinCount = coinCount,
        NewTotalValue = RecalculateTotal(),
        RespinsLeft = (coinCount > 0) ? 3 : respinsRemaining - 1
    };
}

} ```

8. G2S Integration for Hold & Spin

Respin Request: json { "terminal_id": "000003", "spin_id": "parent_spin_id", "respin_number": 1, "coins_so_far": 7, "grid_positions_filled": 7 }

Respin Response: json { "respin_id": "RS1_20260403_000003", "new_coin_value": 250, "new_coins_count": 2, "total_prize_so_far": 5000, "grand_jackpot_check": false }

9. Near Miss Engineering for Coins

```csharp public class NearMissEngine {

public void ApplyNearMissStrategy(VirtualReels reels, string rtpMode) {
    if (rtpMode == "97") {
        // Coloca Moedas logo antes/depois de posições de parada
        // Aumenta visibilidade psicológica
        for (int r = 1; r < 4; r++) {  // Rolos 2-4
            for (int i = 0; i < reels[r].Count; i++) {
                if (reels[r][i] == Coin) {
                    // Blank depois de Moeda (near miss effect)
                    reels[r][(i + 1) % reels[r].Count] = Blank;
                }
            }
        }
    }
}

} ```

10. Audio Sync

```csharp public void PlayHoldAndSpinAudio() { AudioManager.PlayBackground("forroPercussion.wav", loop: true);

OnCoinAdded(() => {
    AudioManager.PlayEffect("coin_metallic.wav");
    AudioManager.IncreaseBPM(respinsRemaining == 3 ? 10 : 5);
});

OnRespinCounterReset(() => {
    AudioManager.PlayEffect("chicote_grito.wav");  // Whip + "Ê-ta!"
});

OnHoldAndSpinComplete(() => {
    AudioManager.PlayBackground("flauta_jackpot.wav");
});

} ```

11. Hardware Spec Notes

• CPU: Mínimo i5 (para cálculos de decomposição rápidos)
• Network: Conexão estável obrigatória (respins requerem servidor)
• Audio: Subwoofer para bumbo de forró

12. Testing Metrics

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.