Tucano Bonito — Technical Design Document (TDD)

Versão: 1.0 Data: 2026-04-03 Arquitetura: Megaways Engine com Pool Finito Integration Plataforma: Lottopar (PR Regulation)

1. Visão Geral Técnica

Tucano Bonito implementa um motor Megaways adaptatado para operar dentro do framework regulado Lottopar. Diferente de um RNG puro, cada giro é pré-determinado pelo servidor, que escolhe a altura das bobinas e distribui símbolos para alcançar um prêmio específico.

Arquitetura em Camadas: ┌──────────────────────────────────────┐ │ Front-end (HTML5/WebGL) │ │ - Renderização de Grade │ │ - Animações (Cascatas, etc) │ └──────────────┬──────────────────────┘ │ JSON RPC ┌──────────────▼──────────────────────┐ │ VltCore (C#/.NET Core) │ │ - Pool Finito Builder │ │ - Reel Strip Manager │ │ - Payout Engine │ └──────────────┬──────────────────────┘ │ TCP/SSL ┌──────────────▼──────────────────────┐ │ Lottopar Server (Regulado) │ │ - Gerador de Bilhetes │ │ - Validador de Resultados │ └──────────────────────────────────────┘

2. Reel Strip Configuration

2.1 Definição de Reel Strips

Cada bobina tem um "strip" (fita) contendo símbolos em ordem. A altura variável significa que cada giro pode usar um subset diferente do strip.

Reel 1 (Esquerda) - Premium Focus: ``` [Tucano, Arara, Sapo, Fruta1, Fruta2, Tucano, Arara, Sapo, Fruta1, Tucano, Arara, Fruta2, Sapo, Tucano, Arara, Fruta1, Sapo, Fruta2, Tucano, Arara]

Tamanho: 20 posições Peso do Tucano: 4/20 (20% - mais frequente para iniciar combos) Peso da Arara: 4/20 Peso do Sapo: 4/20 Peso Frutas: 8/20 ```

Reel 2-5 (Meio) - Balanced: ``` [Sapo, Fruta1, Fruta2, Tucano, Arara, Sapo, Fruta1, Arara, Tucano, Fruta2, Sapo, Tucano, Arara, Fruta1, Sapo, Fruta2, Arara, Tucano, Fruta1, Sapo]

Tamanho: 20 posições Pesos distribuídos uniformemente ```

Reel 6 (Direita) - Premium Heavy: ``` [Tucano, Tucano, Arara, Sapo, Fruta1, Tucano, Arara, Tucano, Fruta2, Sapo, Tucano, Arara, Fruta1, Tucano, Sapo, Fruta2, Tucano, Arara, Tucano, Fruta1]

Tamanho: 20 posições Peso do Tucano: 8/20 (40% - máximo para finalizar combos) ```

Tracker (Horizontal): ``` [Ovo de Ouro, Sapo, Fruta1, Fruta2, Sapo, Ovo de Ouro, Fruta1, Fruta2, Sapo, Ovo de Ouro, Ovo de Ouro, Sapo, Fruta1, Ovo de Ouro, Sapo, Fruta2]

Tamanho: 16 posições Peso do Wild (Ovo): 4/16 (25% - raro mas impactante) ```

2.2 Seleção Dinâmica de Height

O servidor não escolhe símbolos aleatoriamente. Ele escolhe um Template de Altura baseado no prêmio que precisa entregar:

Template Library:

Seleção de Template (Pseudocódigo):

python def select_template(prize_to_deliver): """ Seleciona template baseado no prêmio esperado """ if prize_to_deliver < 2.0: # Muito baixo return MINIMALIST elif prize_to_deliver < 10.0: return STANDARD elif prize_to_deliver < 50.0: return EXPANDED else: # Para prêmios altos, pode usar MAX_MEGA # (aumenta chance de bônus ser acionado) return [EXPANDED, MAX_MEGA] # Mix

3. Algoritmo de Ways Calculator

3.1 Validação de Combinações

Uma vez que os símbolos estão dispostos, o motor calcula quais combinações pagam:

```python def calculate_ways(grid, reel_heights): """ grid: matriz [6][max_height] com símbolos reel_heights: array de alturas reais de cada rolo

Retorna: lista de combinações vencedoras
"""
winning_combos = []

# Para cada símbolo premium
for symbol_id in PAYABLE_SYMBOLS:
    # Verificar se existe em R1
    if symbol_exists_in_reel(symbol_id, grid[0]):
        # Contar quantas posições em R1
        count_r1 = count_symbol(symbol_id, grid[0])

        # Verificar R2
        if symbol_exists_in_reel(symbol_id, grid[1]):
            count_r2 = count_symbol(symbol_id, grid[1])

            # Verificar R3
            if symbol_exists_in_reel(symbol_id, grid[2]):
                count_r3 = count_symbol(symbol_id, grid[2])

                # Continuar até quebra
                # Se alcançar R6, é vitória completa
                if all_reels_connected(symbol_id, grid, 6):
                    ways = count_r1 * count_r2 * count_r3 * ...
                    payout = ways * PAY_TABLE[symbol_id][num_of_reels]
                    winning_combos.append({
                        'symbol': symbol_id,
                        'ways': ways,
                        'payout': payout
                    })

return winning_combos

```

3.2 Exemplo Prático

Situação na Tela: R1 R2 R3 R4 R5 R6 -- -- -- -- -- -- Arara Arara Arara Sapo ... ... Sapo Sapo Sapo ... ... ... Fruta Fruta Fruta ... ... ...

Cálculo: - Símbolo: Arara - Posições em R1: 1 - Posições em R2: 1 - Posições em R3: 1 - Posições em R4: 0 (Sapo, não Arara - quebra!) - Ways: 1 × 1 × 1 = 1 way - Payout (3 símbolos): 1 × 2.5x = 2.5x aposta

4. Pool Finito Integration (Scenario Builder)

4.1 Fluxo de Integração com Lottopar

┌─────────────────┐ │ Jogador aperta │ │ "SPIN" │ └────────┬────────┘ │ ┌────────▼────────────────────┐ │ VltCore envia requisição: │ │ { │ │ "game_id": "TUCANO", │ │ "player_id": "xxx", │ │ "bet_amount": 40.00 │ │ } │ └────────┬────────────────────┘ │ TCP/SSL ┌────────▼──────────────────────────┐ │ Lottopar Server: │ │ 1. Gera bilhete aleatório │ │ 2. Extrai prêmio do bilhete │ │ 3. Valida prêmio contra RTP │ │ 4. Retorna: "prize": 85.00 │ └────────┬──────────────────────────┘ │ ┌────────▼────────────────────┐ │ VltCore recebe prêmio: │ │ "prize": 85.00 │ └────────┬────────────────────┘ │ ┌────────▼────────────────────────────┐ │ Scenario Builder: │ │ 1. Seleciona template (STANDARD) │ │ 2. Popula símbolos para R$ 85,00 │ │ 3. Retorna grid + reel_heights │ └────────┬──────────────────────────────┘ │ ┌────────▼────────────────────┐ │ Front-end renderiza: │ │ - Grade com símbolos │ │ - Animação de reels │ │ - Cálculo de ways │ │ - Exibição de payout │ └────────────────────────────┘

4.2 Reverse Scenario Builder (Core Algorithm)

Este é o coração da integração. Dado um prêmio, como construir uma grade que pague exatamente este prêmio?

```python def build_winning_grid(target_prize, rtp_curve): """ target_prize: Ex: 85.00 (em reais) rtp_curve: Tabela de frequências de símbolo para este RTP

Retorna: grid (matriz), reel_heights (array), payout (confirmação)
"""

# Passo 1: Decompor prêmio em componentes menores
components = decompose_prize(target_prize)
# Exemplo: [
#     {"symbol": "Tucano", "ways": 6, "payout": 50},
#     {"symbol": "Arara", "ways": 7, "payout": 35}
# ]

# Passo 2: Inicializar grade vazia
grid = [[EMPTY] * 7 for _ in range(6)]

# Passo 3: Plantar sementes (winning symbols)
for component in components:
    plant_cluster(
        grid,
        component['symbol'],
        component['ways'],
        random_position()
    )

# Passo 4: Preencher resto com bloqueadores
fill_with_blockers(grid)

# Passo 5: Validar que nenhuma outra vitória foi criada
validate_no_accidental_wins(grid)

# Passo 6: Confirmar payout
calculated_payout = calculate_ways(grid)
assert abs(calculated_payout - target_prize) < 0.01

return grid, reel_heights, calculated_payout

```

4.3 Estratégia de Bloqueadores (Checkerboard)

Para garantir que nenhuma vitória acidental ocorra, usamos padrão de tabuleiro:

```python def fill_with_blockers(grid): """ Preenche espaços vazios com padrão alternado que previne conexões acidentais """ for row in range(len(grid)): for col in range(len(grid[row])): if grid[row][col] == EMPTY: # Padrão alternado (A, B, A, B...) symbol = BLOCKER_A if (row + col) % 2 == 0 else BLOCKER_B grid[row][col] = symbol

return grid

```

Exemplo visual: ``` Antes: [T, T, , , , , ] [T, T, , , , , ] [, , , , , , ] [, , , , , , ] [, , , , , , ] [, , , , , , ] [, , , , , , _]

Depois (com bloqueadores): [T, T, A, B, A, B, A] [T, T, B, A, B, A, B] [A, B, A, B, A, B, A] [B, A, B, A, B, A, B] [A, B, A, B, A, B, A] [B, A, B, A, B, A, B] [A, B, A, B, A, B, A] ```

Resultado: Nenhum símbolo "A" ou "B" conecta 5+, impossibilitando vitória acidental.

5. Cascata e Reações (Tumble Physics)

5.1 Motor de Cascata

```python class CascadeEngine: def init(self, grid, phantom_buffer): self.grid = grid # 7x7 viewport self.phantom = phantom_buffer # 7x14 (acima) self.cascades = [] self.total_multiplier = 1

def process_cascade(self):
    """
    Loop de cascata até não haver mais vitórias
    """
    cascade_index = 0

    while True:
        cascade_index += 1

        # 1. Detectar clusters vencedores
        winning_clusters = self.find_winning_clusters()

        if not winning_clusters:
            break  # Sem mais vitórias

        # 2. Registrar cascata
        cascade_event = {
            "cascade_num": cascade_index,
            "winning_clusters": winning_clusters,
            "multiplier": cascade_index + 1,  # 1x, 2x, 3x...
            "payout": sum(c.payout for c in winning_clusters)
        }
        self.cascades.append(cascade_event)

        # 3. Explodir símbolos
        self.explode_clusters(winning_clusters)

        # 4. Cair símbolos (gravity)
        self.apply_gravity()

        # 5. Repor do Phantom Buffer
        self.replenish_from_phantom()

    return self.cascades

def find_winning_clusters(self):
    """
    Usa Flood Fill para detectar clusters
    """
    visited = [[False] * 7 for _ in range(7)]
    clusters = []

    for row in range(7):
        for col in range(7):
            if not visited[row][col]:
                cluster = self.flood_fill(row, col, visited)
                if len(cluster) >= 5:  # Min cluster size
                    clusters.append(cluster)

    return clusters

def flood_fill(self, row, col, visited):
    """
    Algoritmo clássico de Flood Fill (Paint Bucket)
    """
    if row < 0 or row >= 7 or col < 0 or col >= 7:
        return []
    if visited[row][col]:
        return []

    symbol = self.grid[row][col]
    if symbol == EMPTY or symbol == BLOCKER:
        return []

    visited[row][col] = True
    cluster = [(row, col)]

    # Verificar 4 vizinhos
    for dr, dc in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
        cluster.extend(
            self.flood_fill(row + dr, col + dc, visited)
        )

    return cluster

def explode_clusters(self, clusters):
    """
    Remove símbolos vencedores da grade
    """
    for cluster in clusters:
        for row, col in cluster:
            self.grid[row][col] = EMPTY

def apply_gravity(self):
    """
    Símbolos caem para preencher vazios
    """
    for col in range(7):
        # Compactar coluna
        non_empty = []
        for row in range(7):
            if self.grid[row][col] != EMPTY:
                non_empty.append(self.grid[row][col])

        # Preencher de cima para baixo
        for row in range(7):
            if row < 7 - len(non_empty):
                self.grid[row][col] = EMPTY
            else:
                self.grid[row][col] = non_empty[row - (7 - len(non_empty))]

def replenish_from_phantom(self):
    """
    Puxar símbolos do Phantom Buffer acima
    """
    for col in range(7):
        # Contar vazios no topo
        empty_count = 0
        for row in range(7):
            if self.grid[row][col] == EMPTY:
                empty_count += 1
            else:
                break

        # Puxar do phantom
        for i in range(empty_count):
            symbol = self.phantom[14 - 1 - i][col]  # Pull from bottom of phantom
            self.grid[i][col] = symbol

        # Scroll phantom para cima (simular novo drop)
        self.phantom.pop()  # Remove última linha
        self.phantom.insert(0, self.generate_new_symbols(col))

```

6. Phantom Buffer (Extended Grid)

6.1 Arquitetura do Phantom Buffer

``` Memory Layout (Column View): ┌─────────────────────────────────┐ │ Phantom Buffer (7x14) - Above │ │ [P0,0] [P0,1] ... [P0,13] │ │ [P1,0] [P1,1] ... [P1,13] │ │ ... │ │ [P13,0][P13,1]... [P13,13] │ ├─────────────────────────────────┤ │ Viewport (7x7) - Visible │ │ [V0,0] [V0,1] ... [V0,6] │ │ [V1,0] [V1,1] ... [V1,6] │ │ ... │ │ [V6,0] [V6,1] ... [V6,6] │ └─────────────────────────────────┘

Total Memory: 7 x 21 = 147 slots por coluna ```

6.2 Preenchimento do Phantom Buffer

Quando símbolos caem durante cascatas, eles vêm do Phantom Buffer. O buffer deve ser pré-populado durante a construção da grade:

```python def build_phantom_buffer_content(target_prize, cascades_expected): """ Pré-computa conteúdo do phantom buffer para garantir que cascatas entregarão o prêmio correto """

phantom = [[EMPTY] * 7 for _ in range(14)]
remaining_prize = target_prize

for cascade in range(cascades_expected):
    prize_for_this_cascade = remaining_prize / (cascades_expected - cascade)

    # Selecionar símbolos que renderizarão este prêmio
    symbols = select_symbols_for_prize(prize_for_this_cascade)

    # Popular linha do phantom
    for col in range(7):
        phantom[cascade][col] = symbols[col]

    remaining_prize -= prize_for_this_cascade

# Preencher resto aleatoriamente
for row in range(cascades_expected, 14):
    for col in range(7):
        phantom[row][col] = random_non_winning_symbol()

return phantom

```

7. Feature Buy (Compra de Bônus)

7.1 Fluxo de Implementação

Player clica "Comprar Bônus" │ ▼ ┌────────────────────────────┐ │ VltCore verifica saldo: │ │ Custo = 100x aposta base │ │ = 100 × R$ 1,00 = R$ 100 │ └────────┬───────────────────┘ │ Débito validado ▼ ┌────────────────────────────┐ │ Envia aposta de R$ 100 │ │ para Lottopar Server │ └────────┬───────────────────┘ │ Retorna: prêmio ▼ ┌────────────────────────────┐ │ Prêmio retornado: R$ 450 │ │ (exemplo) │ └────────┬───────────────────┘ │ ▼ ┌────────────────────────────┐ │ Construir Bônus Script: │ │ - Forçar 4 Scatters │ │ - Distribuir R$ 450 em 12 │ │ giros com multiplicador │ └────────┬───────────────────┘ │ ▼ ┌────────────────────────────┐ │ Animar entrada no bônus │ │ Executar 12 giros grátis │ └────────────────────────────┘

7.2 Construtor de Script de Bônus

```python def build_bonus_script(feature_buy_prize, num_spins=12): """ Dado um prêmio (ex: R$ 450), distribui em N giros com multiplicador crescente """

bonus_script = []
remaining = feature_buy_prize

for spin_num in range(num_spins):
    multiplier = spin_num + 1  # 1x, 2x, 3x...

    # Cálculo de quanto este giro deve "ganhar" antes de multiplicar
    base_win = remaining / (num_spins - spin_num)

    # Selecionar template de altura que renderize este ganho
    reel_template = select_template(base_win)

    # Construir grid para este giro
    grid = build_grid_for_prize(base_win, reel_template)

    # Calcular cascatas
    cascades = process_cascades(grid)

    spin_script = {
        "spin_num": spin_num + 1,
        "reel_heights": reel_template,
        "grid": grid,
        "cascades": cascades,
        "base_win": base_win,
        "multiplier": multiplier,
        "final_win": cascades_total(cascades) * multiplier
    }

    bonus_script.append(spin_script)
    remaining -= spin_script["final_win"]

# Validação final
total_distributed = sum(s["final_win"] for s in bonus_script)
assert abs(total_distributed - feature_buy_prize) < 0.01

return bonus_script

```

8. Tracker (Top Reel) Implementation

8.1 Física do Tracker

O Tracker é uma bobina horizontal que desliza sobre as colunas 2, 3, 4, 5:

```python class TrackerMechanics: def init(self): self.tracker_symbols = [] # 4 posições self.tracker_position = 0 # 0-15 (posição no strip)

def spin_tracker(self):
    """
    Tracker gira junto com os rolos verticais
    """
    # Selecionar 4 símbolos consecutivos do tracker strip
    start_pos = random.randint(0, 11)  # 16 - 4 = 12

    self.tracker_symbols = [
        TRACKER_STRIP[start_pos + i] for i in range(4)
    ]

    return self.tracker_symbols

def apply_tracker_to_grid(self, grid):
    """
    Símbolos do tracker contam como estando
    no topo da coluna correspondente
    """
    # Tracker está sobre colunas 2, 3, 4, 5 (índices 1, 2, 3, 4)
    for tracker_col in range(4):
        grid_col = tracker_col + 1

        # Inserir símbolo do tracker como "virtual row 0"
        # Na prática, quando calculamos ways, contamos tracker também
        symbol = self.tracker_symbols[tracker_col]
        if symbol != EMPTY:
            # Este símbolo "contribui" para as ways
            grid[0][grid_col] = symbol

def handle_tracker_cascades(self, winning_clusters):
    """
    Se um símbolo do tracker participa de uma vitória,
    ele é removido e símbolos deslizam da direita
    """
    for cluster in winning_clusters:
        for row, col in cluster:
            if row == -1:  # Sinal especial para tracker
                # Remover símbolo do tracker
                tracker_col = col - 1  # Converter índice
                self.tracker_symbols[tracker_col] = EMPTY

    # Deslizar símbolos restantes para a esquerda
    self.tracker_symbols = [s for s in self.tracker_symbols if s != EMPTY]

    # Repor um novo símbolo da direita
    new_symbol = TRACKER_STRIP[random.randint(0, 15)]
    self.tracker_symbols.append(new_symbol)

```

8.2 Integração com Grid

```python def calculate_ways_with_tracker(grid, tracker): """ Ways calculator que leva em conta tracker """

# Aplicar tracker logicamente
effective_grid = [row[:] for row in grid]  # Deep copy

# Tracker coluna 2 (índice 1) tem símbolo tracker.symbols[0]
# Tracker coluna 3 (índice 2) tem símbolo tracker.symbols[1]
# etc...

# Quando verificamos ways, contamos como se o tracker
# adicionasse uma posição extra ao topo

for symbol_id in PAYABLE_SYMBOLS:
    # Para cada símbolo, contar em qual coluna aparece
    appearances = []

    for col in range(6):
        count = 0

        # Contar no grid normal
        for row in range(7):
            if effective_grid[row][col] == symbol_id:
                count += 1

        # Se tracker tem este símbolo nesta coluna, +1
        if col >= 1 and col <= 4:
            tracker_col = col - 1
            if tracker.tracker_symbols[tracker_col] == symbol_id:
                count += 1

        appearances.append(count)

    # Calcular ways (produto das contagens)
    # ...resto do cálculo normal...

```

9. RTP Curve Implementation

9.1 Tabelas de RTP

python RTP_CURVES = { "90": { "name": "Rua (Baixa Denominação)", "denominations": [0.10, 0.20, 0.50], "hit_frequency": 0.18, "max_multiplier": 12, "max_ways": 20000, "max_win_cap": 50000, "symbol_distribution": { "Tucano": 0.12, "Arara": 0.15, "Sapo": 0.18, "Frutas": 0.55 } }, "94": { "name": "Standard", "denominations": [2.00, 3.00, 5.00], "hit_frequency": 0.20, "max_multiplier": 18, "max_ways": 50000, "max_win_cap": 100000, "symbol_distribution": { "Tucano": 0.14, "Arara": 0.16, "Sapo": 0.20, "Frutas": 0.50 } }, "97": { "name": "VIP (Alta Denominação)", "denominations": [10.00], "hit_frequency": 0.22, "max_multiplier": 25, "max_ways": 117649, "max_win_cap": 250000, "symbol_distribution": { "Tucano": 0.16, "Arara": 0.18, "Sapo": 0.22, "Frutas": 0.44 } } }

9.2 Seleção de RTP em Runtime

```python def determine_rtp_for_spin(denomination, player_status): """ Escolhe qual RTP usar para este jogador/máquina """

if denomination <= 0.50:
    return "90"  # Rua
elif denomination <= 5.00:
    return "94"  # Standard
else:
    return "97"  # VIP

```

10. Payload JSON para Cliente

10.1 Estrutura de Resposta de Giro

```json { "spin_id": "SPIN_2026040312345", "timestamp": "2026-04-03T14:23:45.123Z", " "reel_config": { "heights": [4, 5, 4, 5, 4, 6], "total_ways": 7200, "template": "STANDARD_02" },

"initial_grid": [ [ {"id": 1, "symbol": "Tucano"}, {"id": 2, "symbol": "Arara"}, ... ], ... ],

"winning_combinations": [ { "symbol": "Arara", "count": 4, "ways": 8, "payout": 20.00 } ],

"cascades": [ { "cascade_num": 1, "removed_symbols": [[0,0], [0,1], [1,0], [1,1]], "new_symbols_grid": [ [ {"id": 3, "symbol": "Sapo"}, ... ] ], "new_winning_combos": [ { "symbol": "Sapo", "count": 5, "ways": 12, "payout": 15.00 } ], "multiplier": 2 } ],

"total_win": 35.00, "bonus_triggered": false } ```

10.2 Payload de Bônus

json { "bonus_session_id": "BONUS_2026040312346", "trigger_type": "free_spins", "num_spins": 12, "spins": [ { "spin_num": 1, "reel_heights": [6, 6, 5, 6, 5, 6], "grid": [...], "cascades": [...], "multiplier": 1, "spin_win": 5.00, "total_with_multiplier": 5.00 }, { "spin_num": 2, "reel_heights": [7, 7, 6, 7, 6, 7], "grid": [...], "cascades": [...], "multiplier": 2, "spin_win": 12.50, "total_with_multiplier": 25.00 }, ... ], "total_bonus_win": 1500.00 }

11. Hardware Specifications

11.1 Cabinet Requirements

11.2 Requisitos de Software

• SO: Windows 10 IoT Enterprise
• Framework: .NET 6.0+
• API: JSON over HTTPS/TLS 1.2+
• Banco de Dados (Local): SQLite para cache

12. SAS 6.02 / G2S Protocol

12.1 Integração SAS (Slot Accounting System)

Tucano Bonito deve reportar eventos ao controlador SAS da máquina:

Eventos Reportados via SAS 6.02: ├─ Machine Cash In/Out ├─ Meters Update (Coin-In, Coin-Out, Jackpots) ├─ Door Open/Close ├─ Ticket Printed ├─ Error Codes └─ Game Round Details

12.2 G2S (Game to System) Protocol

Comunicação com o sistema de supervisão:

G2S Events: ├─ "gamePlay.gameStarted" - Início de giro ├─ "gamePlay.gameEnded" - Fim de giro com resultado ├─ "bonusPlay.bonusStarted" - Entrada em bônus ├─ "bonusPlay.bonusEnded" - Fim do bônus ├─ "meters.meterClosed" - Fechamento de metro └─ "cabinet.systemError" - Erro crítico

13. Validação e Testes

13.1 Cheklist de QA

• [ ] 10.000 spins de base, verificar RTP dentro de ±2%
• [ ] 1.000 bônus, multiplicador máximo nunca excede limite
• [ ] Phantom Buffer nunca fica vazio durante cascata
• [ ] Feature Buy sempre entrega prêmio correto ±1%
• [ ] Tracker colisão com grid nunca quebra cálculo
• [ ] JSON payload válido 100% dos spins
• [ ] Audio sincronizado com eventos
• [ ] Timeout de rede testado (reconectar após 30s)

13.2 Regressão Matemática

```python def regression_test_rtp(num_spins=50000, rtp_target=0.94): """ Testa se RTP observado bate com esperado """ total_coin_in = 0 total_coin_out = 0

for _ in range(num_spins):
    spin_result = run_spin()
    total_coin_in += spin_result.bet_amount
    total_coin_out += spin_result.payout

observed_rtp = total_coin_out / total_coin_in
margin = abs(observed_rtp - rtp_target) / rtp_target

assert margin < 0.02, f"RTP deviation: {margin*100:.2f}%"
print(f"✓ RTP Test Passed: {observed_rtp:.4f} vs {rtp_target:.4f}")

```

14. Performance Optimization

14.1 Object Pooling

Criar e destruir objetos Unity durante cascatas causa lag:

```csharp public class SymbolPool { private Queue pool = new Queue(); private int poolSize = 60;

public Symbol GetSymbol()
{
    if (pool.Count > 0)
        return pool.Dequeue();
    else
        return Instantiate(symbolPrefab);
}

public void ReturnSymbol(Symbol sym)
{
    sym.gameObject.SetActive(false);
    pool.Enqueue(sym);
}

} ```

14.2 Asset Optimization

• Usar Sprite Atlases (combinam múltiplos sprites em 1 textura)
• Comprimir áudio em MP3 (64kbps suficiente)
• Desabilitar partículas em dispositivos com GPU fraca

15. Debugging Tools

15.1 Developer Mode

```python

CMD + Shift + D para entrar em debug mode

Permite:

- Clicar na grade para mudar símbolos manualmente

- Forçar entrada em bônus

- Inspeccionar reel strips e paytable

- Ver valores de RTP em tempo real

```

Conclusão

Este TDD fornece especificação completa para implementação do Tucano Bonito. A integração com Pool Finito da Lottopar é crítica; todo resultado deve ser pré-determinado e validável.

Data de Conclusão: 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.