23 - SETE DE PLATINA

Technical Design Document (TDD)

Referência: Quick Hit Platinum (Light & Wonder) Arquitetura: Lottopar Core (Pool Finito) Status: Design Finalizado Data: 2026-04-03

1. VISÃO GERAL TÉCNICA

Implementação técnica focada em: - Algoritmo de Scatter Spreading (posicionamento direto) - Reel strip otimizado com clusters de Platinas - Lógica de Pick & Match scriptada - Audio Ducking sincronizado com Ladder progression

2. REEL STRIPS E CONFIGURAÇÃO

Configuração Geral

• Rolos: 5
• Posições por Rolo: 48 (múltiplo de 30 linhas)
• Full Cycle: 48^5 = 254.8M combinações

Distribuição de Símbolos

Reel 1

Posição | Símbolo | Frequência | Cluster --------|---------|------------|-------- 0-2 | Platina | 3x | Cluster A 3-5 | Sete | 3x | 6-8 | Bar2 | 3x | 9-11 | Bar1 | 3x | 12-14 | A | 3x | 15-17 | K | 3x | 18-20 | Q | 3x | 21-23 | J | 3x | 24-26 | Platina | 3x | Cluster B 27-29 | Sete | 3x | 30-32 | Bar2 | 3x | 33-35 | Bar1 | 3x | 36-38 | A | 3x | 39-41 | K | 3x | 42-44 | Q | 3x | 45-47 | J | 3x |

Proporção Platina: 6/48 = 12.5% (crítico para Scatter Ladder)

Reels 2-5

Mesmo padrão do Reel 1 para distribuição uniforme.

Probabilidades Derivadas

3. ALGORITMO "SCATTER SPREADING"

Conceito Fundamental

Em lugar de girar rolos virtualmente para encontrar Scatters, o motor posiciona diretamente o número de Scatters necessários na grade.

Fase 1: Decisão de Target

```csharp public int DeterminePlatinasNeeded(decimal ticketWin) {

decimal betMultiplier = ticketWin / totalBet;

if (betMultiplier >= 666.67m) return 9;      // 2000x
if (betMultiplier >= 83.33m) return 8;       // 250x
if (betMultiplier >= 33.33m) return 7;       // 100x
if (betMultiplier >= 16.67m) return 6;       // 50x
if (betMultiplier >= 6.67m) return 5;        // 20x
if (betMultiplier >= 1.67m) return 4;        // 5x
if (betMultiplier >= 0.33m) return 3;        // 1x

return 0; // Sem Scatter payout

} ```

Fase 2: Inserção Direto de Platinas

```csharp public void InsertPlatinas(Grid grid, int platformCount) {

List<Vector2> availablePositions = grid.GetAllPositions();

for (int i = 0; i < platformCount; i++) {

    // Selecionar posição aleatória
    Vector2 pos = availablePositions[Random.Range(0, availablePositions.Count)];

    // Inserir Platina
    grid[pos.row, pos.reel] = Symbol.PLATINA;

    // Remover posição da lista
    availablePositions.Remove(pos);
}

} ```

Fase 3: Trash Fill (Crítico!)

Após inserir Platinas, preencher espaços vazios com símbolos que NÃO formem linhas acidentais.

```csharp public void TrashFill(Grid grid) {

foreach (var emptyPos in grid.GetEmptyPositions()) {

    // 1. Analisar adjacentes
    Symbol left = grid.GetSymbol(emptyPos.reel - 1, emptyPos.row);
    Symbol right = grid.GetSymbol(emptyPos.reel + 1, emptyPos.row);
    Symbol above = grid.GetSymbol(emptyPos.reel, emptyPos.row - 1);
    Symbol below = grid.GetSymbol(emptyPos.reel, emptyPos.row + 1);

    // 2. Criar lista de símbolos PROIBIDOS
    List<Symbol> forbidden = new();
    forbidden.Add(left);
    forbidden.Add(right);
    forbidden.Add(above);
    forbidden.Add(below);

    // 3. Se Platina adjacente, proibir símbolos de alto valor
    if (left.IsPlatina || right.IsPlatina) {
        forbidden.AddRange(GetHighPaySymbols());
    }

    // 4. Selecionar aleatoriamente de símbolos permitidos
    Symbol selected = GetRandomAllowedSymbol(forbidden);
    grid[emptyPos.row, emptyPos.reel] = selected;

    // 5. Validar: Recalcular ganho geral
    decimal newTotal = CalculateWinFromGrid(grid);
    if (newTotal > TargetWin + 0.01m) {
        // Trocar por símbolo mais baixo
        grid[emptyPos.row, emptyPos.reel] = Symbol.NINE;
    }
}

} ```

4. VALIDAÇÃO INTERNA (ANTES DE ENVIAR)

Server-Side Validation Loop

```csharp public bool ValidateScatterLayout(Grid grid, int expectedPlatinas) {

// 1. Contar Platinas
int actualPlatinas = grid.CountSymbols(Symbol.PLATINA);
if (actualPlatinas != expectedPlatinas) {
    LogError($"Platina count mismatch: expected {expectedPlatinas}, got {actualPlatinas}");
    return false;
}

// 2. Verificar distribuição (não todas em coluna)
foreach (var reel in grid.GetReels()) {
    int platinasInReel = reel.CountSymbols(Symbol.PLATINA);
    if (platinasInReel > 3) { // Máximo 3 por rolo
        LogError($"Excessive Platinas in reel: {platinasInReel}");
        return false;
    }
}

// 3. Verificar winlines não-acidentais
int accidentalWins = CountAccidentalLineWins(grid);
if (accidentalWins > 2) {
    LogError($"Excessive accidental wins: {accidentalWins}");
    return false;
}

// 4. Recalcular e validar ganho
decimal calculatedWin = CalculateWinFromGrid(grid);
if (Math.Abs(calculatedWin - TargetWin) > 0.01m) {
    LogError($"Win mismatch: target {TargetWin}, calculated {calculatedWin}");
    return false;
}

return true;

} ```

5. OTIMIZAÇÃO DE REEL STRIPS (CLUSTERS)

Conceito

Para Base Game (giros sem prêmio de Scatter), as fitas virtuais contêm "Clusters" de Platinas que criam o efeito visual de "Passing" (múltiplos símbolos de prêmio passando rápido na animação).

Implementação

```csharp public class ReelStripOptimizer {

public void AddClusters(ReelStrip strip) {

    // Dividir strip em 4 clusters
    int clusterSize = strip.Length / 4;

    for (int c = 0; c < 4; c++) {
        int startIndex = c * clusterSize;

        // Inserir 3 Platinas consecutivas
        for (int p = 0; p < 3; p++) {
            strip[startIndex + p] = Symbol.PLATINA;
        }
    }
}

public void TestClusterFrequency(ReelStrip strip, int spins = 10000) {

    int clustersHit = 0;

    for (int i = 0; i < spins; i++) {
        int randomStop = Random.Range(0, strip.Length);

        // Se stop coincide com cluster
        if (strip[randomStop].IsPlatina) {
            int consecutivePlatinas = CountConsecutivePlatinas(strip, randomStop);
            if (consecutivePlatinas >= 2) {
                clustersHit++;
            }
        }
    }

    float frequency = (float)clustersHit / spins;
    Debug.Log($"Cluster hit frequency: {frequency * 100}%");
}

} ```

6. LÓGICA DO PICK & MATCH BÔNUS

Estrutura de Grade (20 Peças)

```csharp public class PickMatchGrid {

public Tile[,] tiles = new Tile[4, 5]; // 4 linhas × 5 colunas = 20
public List<TileType> remainingPrizes;
public int revealCount = 0;
public const int MAX_REVEALS = 20;

public void Initialize(int scatterCount) {

    // Determinar prêmios baseado em scatters
    DetermineAwardBudget(scatterCount);

    // Preencher 20 quadrados com prêmios
    foreach (var position in GetAllPositions()) {
        TileType type = SelectRandomPrize();
        tiles[position.row, position.col] = new Tile {
            Type = type,
            IsRevealed = false
        };
    }
}

} ```

Algoritmo de Revelação

```csharp public class PickMatchController {

public void RevealTile(Vector2 position) {

    if (revealCount >= 20) return; // Fim do jogo

    Tile tile = grid.tiles[(int)position.y, (int)position.x];
    tile.IsRevealed = true;
    revealCount++;

    // Efeito de espelho quebrando
    PlaySoundEffect("mirror_break");
    AnimateRevealing(position);

    // Detectar match
    if (DetectMatch(tile.Type)) {
        ProcessMatch(tile.Type);
    } else {
        // Continuar aguardando
    }
}

private bool DetectMatch(TileType type) {

    int count = 0;
    foreach (var tile in grid.tiles) {
        if (tile.IsRevealed && tile.Type == type) {
            count++;
        }
    }

    return count == 3; // Exatamente 3 iguais
}

private void ProcessMatch(TileType type) {

    // 1. Animar match (brilho, explosão)
    // 2. Remover peças da grade
    // 3. Aplicar prêmio (giros ou moeda)
    // 4. Novas peças caem de cima
    // 5. Retornar ao estado de revelação
}

} ```

Scriptagem Pré-Determinada

O resultado da escolha é decidido antes do jogador tocar na tela:

json { "pick_match_outcome": { "total_spins": 15, "multiplier": 2, "total_bonus": 30, "reveal_sequence": [ { "index": 0, "type": "5_spins", "match_number": 2 }, { "index": 5, "type": "2x_mult", "match_number": 1 }, { "index": 12, "type": "5_spins", "match_number": 3 }, ... ] } }

7. AUDIO DUCKING NA LADDER

Implementação

```csharp public class AudioDuckingSystem {

private float baseVolume = 1.0f;

public void DuckMusicOnLadderProgress() {

    // Quando Scatter encontrado
    LadderManager.OnScatterDetected += () => {

        // Reduzir música para 50%
        DOTween.To(
            () => audioMixer.GetFloat("Music", out float v) ? v : 0,
            x => audioMixer.SetFloat("Music", x),
            0.5f,
            0.3f
        ).SetEase(Ease.OutQuad);

        // Tocar som de sino (HIGH priority)
        audioSource.PlayOneShot(ladderSounds[currentLadderLevel]);

        // Aguardar som terminar
        yield return new WaitForSeconds(0.5f);

        // Restaurar música
        DOTween.To(
            () => audioMixer.GetFloat("Music", out float v) ? v : 0,
            x => audioMixer.SetFloat("Music", x),
            baseVolume,
            0.5f
        ).SetEase(Ease.OutQuad);
    };
}

public void PlayLadderSound(int level) {

    // Escala musical ascendente
    float[] frequencies = {
        262f, // C4
        294f, // D4
        330f, // E4
        349f, // F4
        392f, // G4
        440f, // A4
        494f, // B4
        523f  // C5
    };

    if (level <= 8) {
        // Sintetizar nota usando oscilador
        GenerateChime(frequencies[level]);
    }
}

} ```

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

```csharp public class OutcomeValidator {

public bool ValidateOutcome(Outcome outcome) {

    // 1. Hash validation
    if (!VerifyHash(outcome)) return false;

    // 2. RTP check
    decimal rtp = outcome.totalWin / outcome.totalBet;
    if (rtp < 0.90m || rtp > 1.98m) return false;

    // 3. Scatter count consistency
    int countedScatters = outcome.grid.CountPlatinas();
    if (countedScatters != outcome.expectedScatters) return false;

    // 4. Scatter payout alignment
    decimal expectedScatterPay = GetScatterPaytableValue(countedScatters);
    if (Math.Abs(outcome.scatterWin - expectedScatterPay) > 0.01m) return false;

    // 5. Line win calculation
    decimal calculatedLineWins = CalculateLineWinsFromGrid(outcome.grid);
    decimal totalExpected = outcome.scatterWin + calculatedLineWins;
    if (Math.Abs(outcome.totalWin - totalExpected) > 0.01m) return false;

    // 6. Pick & Match budget validation (se ativado)
    if (outcome.pickMatchTriggered) {
        if (!ValidatePickMatchBudget(outcome.pickMatchPayload)) return false;
    }

    return true;
}

} ```

9. FLUXO COMPLETO DE SPIN

``` 1. REQUER SPIN ├─ Pool sorteia TicketWin ├─ OutcomeBuilder calcula Scatter target └─ Insere Platinas, Trash Fill, Valida

1. JSON ENVIADO À UNITY ├─ Grid (5×3 com Platinas) ├─ Reel stops [0-47 para cada rolo] └─ Flags: pick_match_triggered

2. ANIMAÇÃO REELS ├─ 3.5s de rotação ├─ Frenagem nos índices └─ Audio: clique suave ao parar

3. DETEÇÃO DE SCATTER ├─ Contar Platinas visíveis ├─ Se < 6: Mostrar ganho imediato └─ Se >= 6: Transição para Pick & Match

4. PICK & MATCH (Opcional) ├─ Iniciar minigame ├─ Loop até 20 cliques ou fim └─ Acumular prêmios

5. END SCREEN ├─ Resumo de ganhos ├─ Opção: Nova rodada ou Sair └─ Saldo atualizado ```

10. INTEGRAÇÃO VTLCORE.DLL

```csharp [DllImport("VltCore.dll")] public static extern int GenerateSpinSeteaPlatina( double totalBet, IntPtr outputBuffer, int bufferSize );

public class CoreInterface {

public Outcome RequestSpin(decimal bet) {

    byte[] buffer = new byte[8192]; // Espaço para grid 5×3
    GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);

    try {
        int result = GenerateSpinSeteaPlatina(
            (double)bet,
            handle.AddrOfPinnedObject(),
            buffer.Length
        );

        if (result != 0) throw new Exception($"Core error: {result}");

        string json = Encoding.UTF8.GetString(buffer);
        return JsonConvert.DeserializeObject<Outcome>(json);
    } finally {
        handle.Free();
    }
}

} ```

11. ESPECIFICAÇÕES DE HARDWARE

Requisitos

• CPU: Intel Core i5 (6ª gen)+
• RAM: 4GB DDR4
• SSD: 256GB
• GPU: NVIDIA GTX 750+
• Display: 24", 1920×1080, 60Hz
• Áudio: Sistema 5.1

12. PROTOCOLO SAS/G2S

Eventos registrados: 1. SPIN_INITIATED 2. PLATINA_COUNT: N 3. SCATTER_PAYOUT: R$ X.XX 4. PICK_MATCH_START (se ≥6 Platinas) 5. PICK_MATCH_END: Total R$ X.XX 6. SPINS_AWARDED: N Giros 7. SESSION_END: Total net R$ X.XX

13. TESTES E VALIDAÇÃO

Test Case 1: Scatter Detection

``` Input: 6 Platinas posicionadas randomicamente Expected: 50x aposta + Pick & Match ativado

Verificações: 1. Grid apresenta exatamente 6 Platinas 2. Ganho calculado = 50x × aposta 3. Pick & Match inicializa com prêmios apropriados 4. Audio ducking funciona corretamente ```

Test Case 2: Trash Fill Integrity

``` Input: 6 Platinas em posições aleatórias Expected: Nenhuma linha acidental de 3+ símbolos

Verificações: 1. Contar linhas não-intencionais 2. Máximo 2 linhas acidentais permitidas 3. Recalcular ganho total 4. Deve estar dentro de ±0.01 do target ```

Stress Test (1M giros)

Métricas esperadas: - RTP: 94% ± 1.5% - Hit Frequency: 35-40% - Scatter Frequency: 12.5% ± 0.5% - Average spin: 4.5s - Memory stable

Documento Finalizado: 03/04/2026 Versão: 1.0 - Draft Final

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.