Technical Design Document (TDD) - Roda da Riqueza

Projeto: 05 - Roda da Riqueza Versão: 1.0 Data: 2026-04-03

1. Wheel Engine Architecture

```csharp public class WheelBonusEngine { private Wheel wheelInstance; private int[] selectedFatias; // Fatias sorteadas (1-12)

public void TriggerWheel(decimal originalWager) {
    // 1. Servidor já determinou o prêmio
    int targetPrize = PoolFiniteClient.GetWheelPrize();

    // 2. Seleciona fatia que será "paragem"
    int winningFatiaIndex = SelectWinningFatia(targetPrize);

    // 3. Inicia animação da roda
    StartWheelAnimation(winningFatiaIndex);

    // 4. Paga prêmio
    Player.Balance += targetPrize;
}

private int SelectWinningFatia(int targetPrize) {
    // Encontra uma fatia que resulta no prêmio alvo
    // Exemplo: se alvo é 5.000 centavos e aposta foi 5.000, fatia = 100x

    for (int i = 0; i < 12; i++) {
        if (wheelInstance.Fatias[i].Multiplicador * originalWager == targetPrize) {
            return i;
        }
    }
    return 0;  // Fallback
}

public void StartWheelAnimation(int targetFatiaIndex) {
    const int startAngularVelocity = 720;  // °/s (2 revolutions/sec)
    const float totalDuration = 5.0f;       // seconds
    const float anglePerFatia = 30;         // 360/12

    // Calcula ângulo alvo
    float targetAngle = (targetFatiaIndex * anglePerFatia) % 360;

    // Simula "fricção" da roda
    RotateWheelWithFriction(startAngularVelocity, targetAngle, totalDuration);

    // Toca som do "clique" final
    PlayWheelClickSound();
}

private void RotateWheelWithFriction(int startVel, float targetAngle, float duration) {
    // Implementação de deceleration via keyframe animation
    // Frame 1: 720°/s
    // Frame (0.5s): 600°/s
    // Frame (1.0s): 400°/s
    // Frame (2.0s): 100°/s (começando a desacelerar visivelmente)
    // Frame (3.0s): 20°/s
    // Frame (5.0s): 0°/s (para exatamente no alvo)

    float elapsedTime = 0;
    while (elapsedTime < duration) {
        float progress = elapsedTime / duration;  // 0.0 to 1.0
        float easeOutFactor = 1 - (progress * progress);  // quadratic easing

        float currentVelocity = startVel * easeOutFactor;
        wheelInstance.RotateBy(currentVelocity * Time.DeltaTime);

        elapsedTime += Time.DeltaTime;
    }

    // Final snap to exact position
    wheelInstance.SetAngle(targetAngle);
}

} ```

2. Wheel Fatia Weights (RTP Configuration)

```csharp public class WheelFatiaConfiguration {

public static Dictionary<int, WheelFatia> GetFatiasRTP94() {
    return new Dictionary<int, WheelFatia> {
        { 0, new WheelFatia(5, 0.50) },     // 50% - Consolação
        { 1, new WheelFatia(10, 0.30) },    // 30% - Pequeno
        { 2, new WheelFatia(25, 0.12) },    // 12% - Médio
        { 3, new WheelFatia(50, 0.05) },    // 5% - Grande
        { 4, new WheelFatia(100, 0.02) },   // 2% - Mega
        { 5, new WheelFatia(1000, 0.01) },  // 1% - Jackpot
        // Repetir para todas as 12 fatias (mesmas proporções)
    };
}

public static Dictionary<int, WheelFatia> GetFatiasRTP97() {
    // RTP 97%: Aumenta pesos das fatias altas
    return new Dictionary<int, WheelFatia> {
        { 0, new WheelFatia(5, 0.30) },     // 30% (reduzido)
        { 1, new WheelFatia(10, 0.35) },    // 35%
        { 2, new WheelFatia(25, 0.20) },    // 20% (aumentado)
        { 3, new WheelFatia(50, 0.10) },    // 10% (aumentado)
        { 4, new WheelFatia(100, 0.04) },   // 4%
        { 5, new WheelFatia(1000, 0.01) },  // 1% - Jackpot
        // ... repete
    };
}

}

public class WheelFatia { public int Multiplicador { get; set; } public double Weight { get; set; }

public WheelFatia(int mult, double weight) {
    Multiplicador = mult;
    Weight = weight;
}

} ```

3. Reel Strips para 3x3 Layout

Ultra-Densa (Baixa Volatilidade)

``` Rolo 1 (30 paradas): 00-03: RODA (cluster) 04-05: 7-Wild 06-09: RODA again 10-11: Diamante 12-29: Símbolos Baixos + Blanks

Rolo 2 (30): Idêntico Rolo 3 (30): Idêntico ```

Efeito: Símbolos RODA são vistos constantemente, criando antecipação contínua.

Near Miss Engineering

csharp public void ApplyNearMissTo3x3(VirtualReels reels) { // Coloca 2 RODA visíveis frequentemente for (int reel = 0; reel < 3; reel++) { for (int i = 0; i < reels[reel].Count - 1; i++) { if (reels[reel][i] == Symbol.RODA && reels[reel][i + 1] == Symbol.RODA) { // Mantém agrupamento // Próxima parada tem alta chance de RODA também if (i < reels[reel].Count - 2) { if (new Random().Next(100) < 60) { // 60% chance reels[reel][i + 2] = Symbol.RODA; } } } } } }

4. Wild Multiplier Mechanics

```csharp public class WildMultiplierEngine {

public int GetMultiplier() {
    double roll = new Random().NextDouble();

    // RTP 94%:
    if (roll < 0.70) return 2;  // 70% chance
    if (roll < 0.95) return 5;  // 25% chance
    return 10;                   // 5% chance
}

public int ApplyWildMultiplier(int baseLineWin) {
    int multiplier = GetMultiplier();
    return baseLineWin * multiplier;
}

} ```

5. Outcome Builder para 3x3 (5 Linhas)

```csharp public int[] BuildWheelOutcome(int targetPrize) { VirtualReels reels = ReelManager.GetReels("94");

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++) {
            int win = Calculate5LinesPay(reels, r1, r2, r3);

            if (win == targetPrize) {
                return new[] { r1, r2, r3 };
            }

            // Também verifica se RODA está presente (prêmio vem da roda)
            if (HasRODA(reels, r1, r2, r3) && targetPrize > 50000) {
                // Roda entregará o prêmio
                return new[] { r1, r2, r3 };
            }
        }
    }
}
return null;

} ```

6. Nudge Algorithm

```csharp public class NudgeEngine {

public bool ShouldApplyNudge() {
    // 20% chance em RTP 94%
    return new Random().Next(100) < 20;
}

public void ApplyNudge(int[] reelStops) {
    // Desloca RODA para a linha de pagamento visível
    for (int reel = 0; reel < 3; reel++) {
        Symbol symbol = GetSymbolAt(reel, reelStops[reel]);
        if (symbol == Symbol.RODA) {
            // "Empurra" para a linha
            reelStops[reel] = FindNearestRODAStop(reel, reelStops[reel]);
            PlayNudgeAnimation(reel);
        }
    }
}

private int FindNearestRODAStop(int reel, int currentStop) {
    // Procura RODA a até 2 posições de distância
    for (int offset = 1; offset <= 2; offset++) {
        int candidate = (currentStop + offset) % ReelManager.GetReelLength(reel);
        if (GetSymbol(reel, candidate) == Symbol.RODA) {
            return candidate;
        }
    }
    return currentStop;
}

} ```

7. G2S Protocol for Wheel Bonus

Spin Request (Normal): json { "terminal_id": "000005", "game_id": "05_RODA_RIQUEZA", "wager": 50000, // R$ 5,00 (5000 centavos) "request_type": "spin" }

Spin Response (Com Roda): json { "spin_id": "SP5_20260403_000005", "prize": 50000, // 100x a aposta (100x 500 centavos) "wheel_bonus_triggered": true, "wheel_fatia_index": 4, // Fatia 100x "crc": "0xDEADBEEF" }

8. Hardware: Wheel Motor Control

```csharp public class PhysicalWheelController { private SerialPort motorPort;

public void InitializeWheel() {
    motorPort = new SerialPort("COM3", 9600);
    motorPort.Open();
}

public void SpinWheelToFatia(int fatiaIndex) {
    // Calcula ângulo alvo
    float targetAngle = (fatiaIndex * 30) % 360;

    // Envia comando ao motor de passo
    byte[] command = new byte[] {
        0x01,  // Motor 1
        (byte)(targetAngle / 1.8),  // Passos (cada passo = 1.8°)
        0x80   // Velocidade/direção
    };

    motorPort.Write(command, 0, command.Length);

    // Aguarda confirmação
    WaitForMotorComplete();
}

private void WaitForMotorComplete() {
    while (motorPort.BytesToRead == 0) {
        System.Threading.Thread.Sleep(10);
    }
    byte response = (byte)motorPort.ReadByte();
    if (response != 0x06) throw new Exception("Motor error");
}

} ```

9. Coin-In Optimization

Devido ao hit frequency alto (33%) e aposta média alta (R$ 5), este jogo processa mais dinheiro/hora:

``` Giros por Hora: 14h × 60 × 60 / 3 = 16.800 giros/hora Coin-In por Hora: 16.800 × R$ 5,00 = R$ 84.000/hora

Vs Jogo 01 (Tesouros - 4s): Giros por Hora: 12.600 giros/hora Coin-In por Hora: 12.600 × R$ 2,00 = R$ 25.200/hora ```

Conclusão: Roda da Riqueza é a máquina de maior volume.

10. Testing Metrics

11. Security & Fraud Prevention

```csharp public class WheelSecurityModule {

public bool ValidateWheelResult(int fatiaIndex, byte[] signature) {
    // HMAC-SHA256 do resultado
    byte[] expectedSignature = HMACSHA256.Compute(
        fatiaIndex.ToString(),
        serverSecret
    );

    return signature.SequenceEqual(expectedSignature);
}

} ```

Status: Pronto para Hardware Integration 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.