Technical Design Document (TDD)

Jogo 17 - Dragão da Fortuna

Versão: 1.0 Data: 2026-04-03 Mercado: Brasil (Paraná - Lottopar) Arquitetura: Pool Finito + State Machine (Link Mode)

1. Visão Geral Técnica

Dragão da Fortuna usa uma arquitetura dual-mode: - Modo 1 (Base): Bingo clássico de 30 bolas - Modo 2 (Link): Slot-like de 15 posições com respins

A transição entre modos é acionada por um evento (6 Bolas de Fogo coletadas) que é pré-decidido pelo bilhete do Pool.

2. Estado de Bilhete Estendido

json { "ticket_id": "TKT-17-20260403-001", "base_mode": { "prize_tier": "LINK_TRIGGER", "prize_amount": 0, "winning_cartela": 2, "winning_pattern": "LINK_BONUS_ENTRY" }, "link_mode": { "enabled": true, "initial_spheres": 6, "respins": 3, "grid_configuration": [ { "position": 0, "value": 100, "type": "MONEY" }, { "position": 5, "value": 2, "type": "MULTIPLIER" }, { "position": 10, "value": 50, "type": "MONEY" }, { "position": 1, "value": 3, "type": "MULTIPLIER" }, { "position": 7, "value": 250, "type": "MONEY" }, { "position": 14, "value": null, "type": "EMPTY" } ], "final_total": 4200, "multiplier_chain": [2, 3, 5] }, "fire_balls_required": [12, 25, 33, 41, 58, 71] }

3. Algoritmo de Engenharia Reversa (Link Edition)

3.1 Cenário: JACKPOT Grande (R$ 10.000,00)

``` Entrada: - Bilhete: Prize = R$ 10.000,00 - Trigger: Tela Cheia no Link (15 esferas preenchidas)

Execução Backend:

1. Definir Objetivo do Link: LINK_TARGET = FULL_GRID (15 esferas) TOTAL_WIN = 10.000

2. Construir Sequência de Respins (Reverse): Preciso entregar R$ 10.000 em 3 respins máximo.

Respins = [ { spheres: 3, values: [100, 2x, 50], subtotal: 150 }, { spheres: 3, values: [3x, 250, +1respin], subtotal: 400 × 2 = 800 }, { spheres: 3, values: [500, 5x, 100], subtotal: 1400 × 3 = 4200 }, { spheres: 6, values: [multiplos], subtotal: (10000 - 4200) / 6 ≈ 967 cada } ]

1. Definir Bolas de Fogo Necessárias (Base Mode): FIRE_BALLS_REQUIRED = 6 (fixo) Distribuí-las nas 30 bolas iniciais para garantir Link Trigger

2. Validação de Constraint: As 6 Bolas de Fogo não devem acidentalmente completar um BINGO (verifica contra padrões de todas as 4 cartelas)

3. Renderização: Cliente recebe: FIRE_BALLS_REQUIRED = [12, 25, 33, 41, 58, 71] Cliente renderiza Bingo Mode até as 6 esferas Transição automática para Link Mode Cliente renderiza respins conforme sequência pré-definida ```

3.2 Código C# - Reverse Link Builder

```csharp public class LinkBonusReverseBuilder { public LinkBonusConfiguration BuildLinkBonusFromTicket( decimal targetWin, int maxRespins = 3) { // Passo 1: Determinar número de esferas necessárias int spheresToPlace = DetermineSpheresToPlace(targetWin); // Exemplo: R$ 10.000 → 15 esferas (FULL GRID)

    // Passo 2: Construir sequência de respins
    var respinSequences = BuildRespinSequence(
        targetWin: targetWin,
        maxRespins: maxRespins,
        targetSpheres: spheresToPlace);

    // Passo 3: Distribuir valores entre respins
    var gridValues = DistributeValuesAcrossGrid(
        totalWin: targetWin,
        respins: respinSequences);

    // Passo 4: Gerar números de Bolas de Fogo para Base Mode
    var fireBalls = GenerateFireBallNumbers(count: 6);

    return new LinkBonusConfiguration
    {
        TotalTargetWin = targetWin,
        GridSpheres = spheresToPlace,
        Respins = respinSequences,
        GridValues = gridValues,
        FireBallsForBaseMode = fireBalls,
        MultiplicatorChain = CalculateMultipliers(respinSequences)
    };
}

private int DetermineSpheresToPlace(decimal targetWin)
{
    // Lógica: Jackpots altos = tela cheia (15)
    // Prêmios médios = 10-12 esferas
    // Pequenos = 5-8 esferas

    if (targetWin >= 5000m) return 15; // FULL GRID
    if (targetWin >= 2000m) return 12;
    if (targetWin >= 1000m) return 10;
    if (targetWin >= 500m) return 8;
    return 6; // Mínimo para triggar Link
}

private List<RespinSequence> BuildRespinSequence(
    decimal targetWin,
    int maxRespins,
    int targetSpheres)
{
    var respins = new List<RespinSequence>();

    // Distribuir esferas entre respins
    int spheresPerRespin = targetSpheres / maxRespins;
    int remainder = targetSpheres % maxRespins;

    for (int i = 0; i < maxRespins; i++)
    {
        int spheresThisRespin = spheresPerRespin + (i < remainder ? 1 : 0);

        respins.Add(new RespinSequence
        {
            RespinIndex = i + 1,
            SpheresToPlace = spheresThisRespin,
            Values = GenerateValuesForRespin(targetWin / maxRespins)
        });
    }

    return respins;
}

private List<SphereValue> DistributeValuesAcrossGrid(
    decimal totalWin,
    List<RespinSequence> respins)
{
    var gridValues = new List<SphereValue>();
    decimal accumulatedValue = 0m;
    var multipliers = new List<int> { 1 };

    foreach (var respin in respins)
    {
        foreach (var value in respin.Values)
        {
            if (value.Type == "MULTIPLIER")
            {
                multipliers.Add(value.MultiplierValue);
            }
            else if (value.Type == "MONEY")
            {
                accumulatedValue += value.MoneyAmount;
                // Aplicar multiplicador do respin anterior
                if (multipliers.Count > 1)
                {
                    value.MoneyAmount *= multipliers.Last();
                }
            }

            gridValues.Add(value);
        }
    }

    // Ajustar último valor para garantir total exato
    if (accumulatedValue != totalWin)
    {
        decimal adjustment = totalWin - accumulatedValue;
        gridValues.Last().MoneyAmount += adjustment;
    }

    return gridValues;
}

private List<int> GenerateFireBallNumbers(int count)
{
    var fireBalls = new List<int>();
    var random = new Random();

    while (fireBalls.Count < count)
    {
        int num = random.Next(1, 91);
        if (!fireBalls.Contains(num))
        {
            fireBalls.Add(num);
        }
    }

    return fireBalls;
}

} ```

4. State Machine para Link Mode

```csharp public enum LinkGameState { WAITING_FOR_FIRE_BALLS, FIRE_BALL_COLLECTED, LINK_ACTIVATED, RESPIN_ROLLING, RESPIN_COMPLETE, CHECKING_GRID, LINK_ENDED, FULL_GRID_ACHIEVED }

public class LinkStateMachine { private LinkGameState currentState = LinkGameState.WAITING_FOR_FIRE_BALLS; private int fireballsCollected = 0; private int currentRespin = 0; private List revealedSpheres = new();

public void OnFireballDetected()
{
    fireballsCollected++;
    currentState = LinkGameState.FIRE_BALL_COLLECTED;

    if (fireballsCollected == 6)
    {
        currentState = LinkGameState.LINK_ACTIVATED;
        TransitionToLinkMode();
    }
}

public void OnRespinComplete()
{
    currentRespin++;
    currentState = LinkGameState.RESPIN_COMPLETE;

    if (revealedSpheres.Count == 15)
    {
        currentState = LinkGameState.FULL_GRID_ACHIEVED;
        PlayGrandJackpotAnimation();
    }
    else if (currentRespin >= maxRespins)
    {
        currentState = LinkGameState.LINK_ENDED;
        EndLinkBonus();
    }
    else
    {
        currentState = LinkGameState.RESPIN_ROLLING;
    }
}

private void TransitionToLinkMode()
{
    // Pausar renderização de Bingo
    // Mostrar tela de transição (dragão voando)
    // Ativar grid de 15 posições
    // Iniciar primeiro respin automaticamente
}

private void PlayGrandJackpotAnimation()
{
    // Dragão solta fogo
    // Esferas brilham
    // Áudio épico
    // Confetti
}

} ```

5. Sincronização de Respins com Pool Finito

5.1 Problema: "Entrega de Esferas"

O desafio é que o cliente não pode "saber" quais esferas vão aparecer até que as revelar. Mas o servidor já decidiu o padrão (Reverse Builder).

Solução: O cliente solicita cada respin como um "Mini-Ticket" do Pool.

```csharp public class RespinTicketSystem { public async Task RequestNextRespin( string linkSessionId, int respinNumber) { // Cliente envia requisição var request = new RespinRequest { LinkSessionId = linkSessionId, RespinNumber = respinNumber, CurrentSphereCount = currentSphereCount, ExpectedPattern = expectedGridPattern // Para validação };

    // Servidor retorna dados pré-decididos
    var respinTicket = await LottoparServer.GetRespinTicket(request);

    // respinTicket contém:
    // - SpherePositions: [0, 5, 10] (onde colocar)
    // - SphereValues: [100, 2x, 50] (valores revelar)
    // - MultiplierApplied: 2 (de respin anterior)

    return RevealSpheres(respinTicket);
}

private RespinResult RevealSpheres(RespinTicket ticket)
{
    // Animar queda de esferas nos positions específicos
    var animationSequence = new List<SphereAnimation>();

    for (int i = 0; i < ticket.SpherePositions.Count; i++)
    {
        animationSequence.Add(new SphereAnimation
        {
            Position = ticket.SpherePositions[i],
            DropDuration = 0.5f,
            Value = ticket.SphereValues[i],
            DelayBetweenSpheres = 0.3f
        });
    }

    return new RespinResult
    {
        Animations = animationSequence,
        AccumulatedValue = ticket.FinalTotal,
        RespinsRemaining = ticket.RespinsRemaining
    };
}

} ```

5.2 Validação de Integridade

```csharp public class LinkIntegrityValidator { public bool ValidateRespinSequence( List completedRespins, LinkBonusConfiguration expectedConfig) { // Verificação 1: Total de esferas int totalSpheres = completedRespins.Sum(r => r.SpheresPlaced); if (totalSpheres > expectedConfig.GridSpheres + 1) { // ERRO: Muitas esferas colocadas LogSecurityAlert("LINK_INTEGRITY_VIOLATION: Too many spheres"); return false; }

    // Verificação 2: Valor acumulado
    decimal accumulatedValue = 0m;
    foreach (var respin in completedRespins)
    {
        accumulatedValue = (accumulatedValue + respin.SumOfValues)
                           * respin.AppliedMultiplier;
    }

    decimal tolerance = expectedConfig.TotalTargetWin * 0.02m; // ±2%
    if (Math.Abs(accumulatedValue - expectedConfig.TotalTargetWin) > tolerance)
    {
        LogSecurityAlert("LINK_INTEGRITY_VIOLATION: Invalid accumulated value");
        return false;
    }

    return true;
}

} ```

6. Detecção de Eventos Críticos

6.1 Eventos que Geram Logs Obrigatórios

```csharp public class LinkEventLogger { public void LogFireballCollected(int ballNumber, int totalCollected) { AuditLog.Record(new { event_type = "FIREBALL_COLLECTED", ball_number = ballNumber, total_collected = totalCollected, progress_percentage = (totalCollected / 6f) * 100, timestamp = DateTime.UtcNow, session_id = CurrentSession.Id }); }

public void LogLinkActivated()
{
    AuditLog.Record(new
    {
        event_type = "LINK_BONUS_ACTIVATED",
        timestamp = DateTime.UtcNow,
        expected_final_win = LinkConfig.TotalTargetWin
    });
}

public void LogRespinComplete(int respinNumber, decimal accumulatedValue)
{
    AuditLog.Record(new
    {
        event_type = "RESPIN_COMPLETE",
        respin_number = respinNumber,
        accumulated_value = accumulatedValue,
        timestamp = DateTime.UtcNow
    });
}

public void LogLinkEnded(decimal finalWin, string reason)
{
    AuditLog.Record(new
    {
        event_type = "LINK_ENDED",
        final_win = finalWin,
        reason = reason, // "NO_MORE_RESPINS" | "FULL_GRID" | "NO_NEW_SPHERES"
        timestamp = DateTime.UtcNow
    });
}

} ```

7. Performance e Otimização

7.1 Animação do Dragão (GPU-Instanced)

```hlsl // Vertex Shader para Dragão

pragma vertex vert

pragma fragment frag

sampler2D _MainTex; float4x4 _DragoonTransform;

v2f vert(appdata v) { v2f o; // Aplicar rotação do dragão ao redor da cena float angle = _Time.y * 2.0; float4x4 rotMatrix = createRotationMatrix(angle);

o.vertex = mul(rotMatrix, v.vertex);
o.uv = v.texcoord;
return o;

}

fixed4 frag(v2f i) : SV_Target { return tex2D(_MainTex, i.uv); } ```

7.2 Profiling Target

Frame Time: 16.67 ms (60 FPS) ├─ Rendering: 8 ms ├─ Link State Machine: 2 ms ├─ Audio (Dragão): 1.5 ms ├─ Reserve: 5 ms

8. Integração com VltCore.dll

```csharp public class LinkVltCoreInterface { [DllImport("VltCore.dll")] public static extern int VLT_RequestLinkRespins( int sessionId, int respinNumber, out LinkRespinData respinData);

public struct LinkRespinData
{
    public int[] SpherePositions;
    public int[] SphereValues;
    public int AppliedMultiplier;
    public decimal FinalTotal;
    public int RespinsRemaining;
}

public async Task<LinkRespinData> GetNextRespin(int sessionId, int respinNumber)
{
    int result = VLT_RequestLinkRespins(
        sessionId: sessionId,
        respinNumber: respinNumber,
        out LinkRespinData data);

    if (result == 0) // SUCCESS
    {
        return data;
    }
    else
    {
        throw new VltCoreException($"Link respins request failed: {result}");
    }
}

} ```

9. Banco de Dados de Link Sessions

```sql CREATE TABLE link_bonus_sessions ( link_session_id TEXT PRIMARY KEY, round_id INTEGER NOT NULL, ticket_id TEXT NOT NULL,

fire_balls_required TEXT, -- JSON array
fire_balls_collected INTEGER DEFAULT 0,

grid_configuration TEXT, -- JSON de 15 posições
respins_allowed INTEGER DEFAULT 3,
respins_completed INTEGER DEFAULT 0,

accumulated_value DECIMAL(10, 2) DEFAULT 0,
final_win DECIMAL(10, 2),

grid_state TEXT, -- "IN_PROGRESS" | "COMPLETED" | "ENDED"
end_reason VARCHAR(50),

started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
ended_at DATETIME,

FOREIGN KEY (round_id) REFERENCES game_rounds(round_id),
FOREIGN KEY (ticket_id) REFERENCES game_rounds(ticket_id)

);

CREATE TABLE link_respins ( respin_id INTEGER PRIMARY KEY AUTOINCREMENT, link_session_id TEXT NOT NULL, respin_number INTEGER NOT NULL,

spheres_placed INTEGER,
sphere_values TEXT, -- JSON
multiplier_applied INTEGER,
subtotal_before_multiplier DECIMAL(10, 2),
subtotal_after_multiplier DECIMAL(10, 2),

completed_at DATETIME DEFAULT CURRENT_TIMESTAMP,

FOREIGN KEY (link_session_id) REFERENCES link_bonus_sessions(link_session_id)

); ```

10. Testes de Validação

10.1 Casos Críticos

Versão

v1.0 - 2026-04-03 Arquiteto: Backend - Oktop.AI Status: Pronto para Implementação

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.