Technical Design Document (TDD)

Jogo 18 - Pesca Premiada

Versão: 1.0 Data: 2026-04-03 Mercado: Brasil (Paraná - Lottopar) Arquitetura: Pool Finito + Input Masking (IK)

1. Visão Geral Técnica

Pesca Premiada usa Input Masking: O cliente recebe entrada do jogador (força do anzol), mas o servidor já decidiu qual peixe será capturado. O cliente então ajusta visualmente o resultado para parecer que corresponde à entrada.

2. Fluxo Técnico

``` 1. Padrão "Duplo H" detectado └─ Bilhete do Pool: Prêmio = R$ 100,00 (Peixe Dourado)

1. Transição para Tela de Pesca └─ Servidor define: FishToCapture = DOURADO @ [640px, 400px]

2. Cliente Renderiza UI de Pesca └─ Botão "PESCAR" ativo └─ Barra de força (0-100%)

3. Jogador Aperta Botão └─ Duração: T segundos (variável) └─ Força Resultante: F = (T / 3.0) * 100%

4. Cliente Calcula Trajetória Naïve (sem IK) └─ TargetPosition = CalculateThrowDistance(F) └─ Exemplo: F=30% → TargetPos = [400px, 500px] (próximo) └─ Exemplo: F=80% → TargetPos = [800px, 600px] (longe)

5. TWIST: Sistema IK Ativa └─ IK Solver ajusta trajetória do anzol └─ Garante interceptação no Peixe Pré-Decidido └─ AnimateHook(startPos, actualFishPos, duration)

6. Animação da Captura └─ Anzol acerta peixe └─ Peixe "puxa linha" └─ Recolher animação

7. Renderizar Prêmio └─ Valor R$ 100,00 exibido └─ Áudio de vitória └─ Retorno ao Bingo ```

3. Classe de Mapeamento de Peixes

```csharp public class FishCaptureSystem { // Definição de tipos de peixe public enum FishType { LAMBARI, // R$ 10 TRAIRA, // R$ 25 DOURADO, // R$ 50 CACHARA, // R$ 100 SURUBIM // R$ 200 }

public class FishData
{
    public FishType Type;
    public Vector2 SpawnPosition;
    public decimal PrizeAmount;
    public string AnimationName;
    public int SizeMultiplier;
}

// Pool de peixes na tela
private List<FishData> activeFishes = new();
private Dictionary<FishType, decimal> fishPrizes = new()
{
    { FishType.LAMBARI, 10m },
    { FishType.TRAIRA, 25m },
    { FishType.DOURADO, 50m },
    { FishType.CACHARA, 100m },
    { FishType.SURUBIM, 200m }
};

public void InitiateFishingMode(decimal targetPrize)
{
    // Determinar qual tipo de peixe corresponde ao prêmio
    FishType targetFish = MapPrizeToFish(targetPrize);

    // Gerar posições aleatórias para peixes "decoy"
    SpawnDecoyFishes();

    // Colocar peixe alvo em posição específica (determinada pelo servidor)
    var targetFishData = new FishData
    {
        Type = targetFish,
        SpawnPosition = GetServerDefinedPosition(targetFish),
        PrizeAmount = targetPrize
    };

    activeFishes.Add(targetFishData);
}

private FishType MapPrizeToFish(decimal prize)
{
    return prize switch
    {
        10m => FishType.LAMBARI,
        25m => FishType.TRAIRA,
        50m => FishType.DOURADO,
        100m => FishType.CACHARA,
        200m => FishType.SURUBIM,
        _ => FishType.LAMBARI // Fallback
    };
}

private void SpawnDecoyFishes()
{
    // Criar 4-6 peixes aleatórios para "enganar" visualmente
    var random = new Random();
    int decoyCount = random.Next(4, 7);

    for (int i = 0; i < decoyCount; i++)
    {
        var decoyFish = new FishData
        {
            Type = (FishType)random.Next(0, 5),
            SpawnPosition = RandomizePosition(),
            PrizeAmount = 0 // Não será capturado
        };

        activeFishes.Add(decoyFish);
    }
}

} ```

4. Inverse Kinematics (IK) para Anzol

4.1 FABRIK Algorithm (Forward And Backward Reaching IK)

```csharp public class HookIKSolver { private Vector2 basePosition; // Ponta da vara private Vector2 targetFishPosition; // Alvo (pré-determinado) private float lineLength = 2.0f; // Comprimento da linha

public Vector2 SolveIK(
    Vector2 userInputTarget,
    Vector2 actualFishPosition,
    float forcePercentage)
{
    // O userInputTarget é baseado na força do jogador
    // Mas o actualFishPosition é pré-determinado pelo servidor

    // FABRIK usa múltiplas iterações para ajustar a trajetória
    Vector2[] bones = new Vector2[3]
    {
        basePosition,           // Base da vara
        basePosition + Vector2.Down * 1.0f, // Meio da linha
        actualFishPosition      // Anzol final (FORÇADO ao peixe)
    };

    // Iterações FABRIK (5-10 iterações para suavidade)
    int iterations = 10;
    for (int i = 0; i < iterations; i++)
    {
        // Forward: Ajustar cada osso para manter distância
        for (int j = 1; j < bones.Length; j++)
        {
            Vector2 direction = (bones[j] - bones[j - 1]).normalized;
            bones[j] = bones[j - 1] + direction * (lineLength / bones.Length);
        }

        // Backward: Forçar última posição ao alvo
        bones[2] = actualFishPosition;
    }

    return bones[2]; // Posição final do anzol
}

public IEnumerator AnimateHookCast(
    Vector2 startPos,
    Vector2 endPos,
    float duration)
{
    float elapsed = 0f;

    while (elapsed < duration)
    {
        elapsed += Time.deltaTime;
        float t = elapsed / duration;

        // Curva de Bézier para queda natural
        Vector2 hookPos = BezierCurve(startPos, endPos, t);

        // Atualizar posição do anzol visualmente
        UpdateHookPosition(hookPos);

        yield return null;
    }
}

private Vector2 BezierCurve(Vector2 start, Vector2 end, float t)
{
    // Curva quadrática para movimento mais natural
    Vector2 control = (start + end) / 2f + Vector2.Down * 0.5f;

    Vector2 p0 = Vector2.Lerp(start, control, t);
    Vector2 p1 = Vector2.Lerp(control, end, t);

    return Vector2.Lerp(p0, p1, t);
}

} ```

4.2 Integração com UI de Força

```csharp public class FishingInputHandler { private float pressStartTime; private float maxForceDuration = 3.0f; private HookIKSolver ikSolver;

public void OnFishButtonPressed()
{
    pressStartTime = Time.time;
    StartCoroutine(AnimateForceBar());
}

public void OnFishButtonReleased()
{
    float forceDuration = Time.time - pressStartTime;
    float forcePercentage = Mathf.Clamp01(forceDuration / maxForceDuration) * 100f;

    // Calcular trajetória "esperada" baseada em força
    Vector2 expectedTarget = CalculateExpectedThrowDistance(forcePercentage);

    // MAS: O servidor já decidiu o peixe alvo
    Vector2 actualFishPos = GetServerDefinedFishPosition();

    // IK Solver ajusta a trajetória
    Vector2 hookedPosition = ikSolver.SolveIK(
        expectedTarget,
        actualFishPos,
        forcePercentage);

    // Animar captura
    StartCoroutine(AnimateCapture(hookedPosition));
}

private Vector2 CalculateExpectedThrowDistance(float forcePercentage)
{
    float distance = (forcePercentage / 100f) * 200f; // 0-200 pixels
    return new Vector2(640 + distance, 400 + distance);
}

private IEnumerator AnimateForceBar()
{
    float elapsed = 0f;
    while (Input.GetMouseButton(0)) // Button held
    {
        elapsed += Time.deltaTime;
        float fillAmount = Mathf.Clamp01(elapsed / maxForceDuration);

        // Atualizar barra visualmente
        UpdateForceBarUI(fillAmount);

        yield return null;
    }
}

} ```

5. Banco de Dados - Fishing Round

```sql CREATE TABLE fishing_rounds ( fishing_id INTEGER PRIMARY KEY AUTOINCREMENT, round_id INTEGER NOT NULL,

trigger_pattern VARCHAR(50), -- "DOUBLE_H" | "PERIMETER"

target_fish_type VARCHAR(20),
target_fish_position TEXT, -- JSON [x, y]
target_prize DECIMAL(10, 2),

player_force_duration FLOAT,
player_force_percentage INT,

hook_final_position TEXT, -- JSON [x, y]
fish_caught_type VARCHAR(20),
prize_amount DECIMAL(10, 2),

fishing_count INT DEFAULT 1, -- 1 for single, 3 for bonus

timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,

FOREIGN KEY (round_id) REFERENCES game_rounds(round_id)

);

CREATE INDEX idx_fishing_round ON fishing_rounds(round_id); ```

6. Validação de Integridade

```csharp public class FishingIntegrityValidator { public bool ValidateFishingResult( FishingRound result, decimal expectedPrize) { // Verificação 1: Prêmio capturado corresponde ao esperado if (Math.Abs(result.PrizeAmount - expectedPrize) > 0.01m) { LogSecurityAlert("FISHING_INTEGRITY_ERROR: Prize mismatch"); return false; }

    // Verificação 2: Força aplicada é razoável (0-100%)
    if (result.PlayerForcePercentage < 0 || result.PlayerForcePercentage > 100)
    {
        LogSecurityAlert("FISHING_INTEGRITY_ERROR: Invalid force percentage");
        return false;
    }

    // Verificação 3: Duração do input é consistente
    float expectedDuration = (result.PlayerForcePercentage / 100f) * 3.0f;
    float tolerance = 0.1f; // ±100ms

    if (Math.Abs(result.PlayerForceDuration - expectedDuration) > tolerance)
    {
        LogSecurityAlert("FISHING_INTEGRITY_ERROR: Force duration mismatch");
        return false;
    }

    return true;
}

} ```

7. Performance (IK Solver)

FABRIK Iterations: 10 (per frame if animating) CPU Cost per Hook: ~0.5 ms Total Budget: < 2 ms for all fishing logic

8. Testes QA

Versão

v1.0 - 2026-04-03 Arquiteto: Graphics/Physics - 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.