Foguete do Milhão — Technical Design Document (TDD)

Versão: 1.0 Data: 2026-04-03 Arquitetura: Crash Game Engine com Exponential Curve Plataforma: Lottopar (PR Regulation)

1. Exponential Curve Generator

1.1 Python Implementation

```python import math

class CrashGameEngine: def init(self, crash_multiplier, k=0.15): self.crash_multiplier = crash_multiplier self.k = k # Coeficiente de volatilidade self.start_time = None self.elapsed = 0

def calculate_multiplier_at_time(self, elapsed_seconds):
    """
    M(t) = e^(k·t)
    """
    multiplier = math.exp(self.k * elapsed_seconds)
    return min(multiplier, self.crash_multiplier)  # Cap at crash point

def has_crashed(self, elapsed_seconds):
    """Verifica se crash já ocorreu"""
    multiplier = math.exp(self.k * elapsed_seconds)
    return multiplier >= self.crash_multiplier

def simulate_game(self, duration_seconds=30):
    """Simula toda a trajetória do foguete"""
    timeline = []

    for t in range(0, duration_seconds + 1):
        mult = self.calculate_multiplier_at_time(t)
        crashed = self.has_crashed(t)

        timeline.append({
            "time": t,
            "multiplier": round(mult, 2),
            "crashed": crashed
        })

        if crashed:
            break

    return timeline

```

1.2 Exemplo de Curva

``` Crash Point: 5.32x k = 0.15

t=0s: M = 1.00x t=1s: M = 1.16x t=2s: M = 1.35x t=3s: M = 1.57x t=4s: M = 1.82x t=5s: M = 2.12x ... t=10s: M = 4.48x t=11s: M = 5.32x → CRASH! ☠️ ```

2. Crash Point Generation & Distribution

2.1 Probabilidade de Crash

```python def generate_crash_point_from_seed(seed_from_lottopar): """ Gera crash point baseado em seed do bilhete Lottopar Mantém RTP em ~94% """

random.seed(seed_from_lottopar)
percentile = random.random()  # 0.0 a 1.0

# Distribuição de crashes (RTP 94%):
if percentile < 0.20:
    # 20% crash super rápido (1.01x - 1.50x)
    return random.uniform(1.01, 1.50)
elif percentile < 0.50:
    # 30% crash rápido (1.50x - 2.50x)
    return random.uniform(1.50, 2.50)
elif percentile < 0.80:
    # 30% crash médio (2.50x - 10.00x)
    return random.uniform(2.50, 10.00)
elif percentile < 0.95:
    # 15% crash alto (10.00x - 50.00x)
    return random.uniform(10.00, 50.00)
else:
    # 5% crash muito alto (50.00x - 1000x)
    return random.uniform(50.00, 1000.00)

```

2.2 Tabela de Probabilidades

RTP Teórico: 94% (validado via simulação de 100.000 spins)

3. JSON Payload

3.1 Game Start Response

json { "game_id": "FOGUETE_001", "crash_point": 5.32, "duration_until_crash_ms": 11000, "betting_window_open": true }

3.2 Real-time Multiplier Updates (WebSocket)

json { "type": "multiplier_update", "elapsed_ms": 5000, "multiplier": 2.12, "crashed": false }

3.3 Crash Event

json { "type": "crash", "crash_point": 5.32, "player_cashout_point": 4.50, "result": "LOSE", // Não sacou a tempo "payout": 0 }

3.4 Successful Cashout

json { "type": "cashout_success", "cashout_point": 3.50, "bet_amount": 10.00, "payout": 35.00, "result": "WIN" }

4. Server-Client Synchronization

4.1 Validação de Cashout

```python def validate_cashout(player_cashout_time, server_crash_time, crash_multiplier): """ Valida que o cliente não está tentando sacar DEPOIS do crash """

if player_cashout_time >= server_crash_time:
    # Fraud! Cliente tentou sacar depois que crash já ocorreu
    return False, "CRASH_BEFORE_CASHOUT"

# Calcular multiplicador no momento do cashout
player_cashout_multiplier = math.exp(0.15 * player_cashout_time)

return True, player_cashout_multiplier

```

4.2 Timing Tolerance

```python

Permitir 200ms de latência de rede

NETWORK_TOLERANCE_MS = 200

server_crash_time_with_tolerance = server_crash_time - (NETWORK_TOLERANCE_MS / 1000)

Se cliente sacar antes disso, válido mesmo com latência

```

5. Bot Management (Optional)

Para jogos tipo Crash, é comum permitir "bots" (auto-cashout automático):

```python class AutoCashoutBot: def init(self, target_multiplier): self.target = target_multiplier

def should_cashout(self, current_multiplier):
    """
    Bot automatic cashout
    """
    return current_multiplier >= self.target

Exemplo: Bot que saca automaticamente em 2.50x

bot = AutoCashoutBot(2.50)

A cada atualização de multiplicador

if bot.should_cashout(current_multiplier): place_cashout() ```

6. RTP Validation

6.1 Test Suite

```python def test_rtp_distribution(num_games=100000): """ Testa se RTP observado bate com esperado """ total_wagered = 0 total_paid = 0

for _ in range(num_games):
    wager = 10.0
    crash_point = generate_crash_point()

    # Simular "média" de cashout (players pegam 70% do crash em média)
    avg_cashout_multiplier = crash_point * 0.70

    payout = wager * avg_cashout_multiplier if avg_cashout_multiplier < crash_point else 0

    total_wagered += wager
    total_paid += payout

observed_rtp = total_paid / total_wagered
expected_rtp = 0.94

assert abs(observed_rtp - expected_rtp) < 0.02
print(f"✓ RTP: {observed_rtp:.4f} (expected {expected_rtp})")

```

7. UI/UX Technical Notes

7.1 Animation Curve

```csharp // Unity C# - Animate foguete subindo public class RocketAnimator : MonoBehaviour { public float k = 0.15f; // Coeficiente exponencial

public void AnimateRocket(float crashTime)
{
    StartCoroutine(AnimateRocketCoroutine(crashTime));
}

IEnumerator AnimateRocketCoroutine(float crashTime)
{
    float elapsedTime = 0f;

    while (elapsedTime < crashTime)
    {
        elapsedTime += Time.deltaTime;

        // Calcular posição do foguete na curva
        float multiplier = Mathf.Exp(k * elapsedTime);
        float yPosition = multiplier * 100f;  // Escala visual

        transform.position = new Vector3(0, yPosition, 0);

        // Atualizar display de multiplicador
        multiplierText.text = $"{multiplier:F2}x";

        yield return null;
    }

    // Crash!
    PlayCrashEffect();
}

} ```

8. Hardware Requirements

9. Performance Metrics

- Frame Rate: 60 FPS (smooth animation) - Network Latency: < 100ms (crítico para fairness) - Responsiveness: < 50ms para cashout acknowledgement - Max concurrent players per server: 1000

10. Security Considerations

10.1 Anti-Cheat

```python def detect_cashout_fraud(client_action_time, server_action_time): """ Detecta tentativa de trapacear (sacar depois do crash) """

if client_action_time > server_action_time + TOLERANCE:
    log_fraud_attempt(player_id, "late_cashout")
    flag_account_for_review()
    return False

return True

```

10.2 Seed Validation

python def validate_seed_integrity(seed, signature): """ Valida que o seed veio genuinamente da Lottopar """ expected_sig = hmac.sha256(seed, LOTTOPAR_SECRET) return hmac.compare_digest(signature, expected_sig)

11. SAS 6.02 Integration

Events logged: - Game Start - Cashout Attempt - Crash Event - Payout - Fraud Detection

Conclusão

Foguete do Milhão é implementativamente simples (exponential curve) mas critica em latência de rede e anti-fraude. A integração com Lottopar seed é fundamental para fairness.

Data: 2026-04-03 Status: Pronto para Desenvolvimento

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.