O Grande Circo — Technical Design Document (TDD)

Versão: 1.0 Data: 2026-04-03 Arquitetura: Sticky Wilds + Expanding Multipliers Plataforma: Lottopar

1. Sticky Wilds Implementation

1.1 Reel Strip com Wilds

```python REEL_1 = [ "ACROBATA", "LEAO", "TRAPEZISTA", "WILD", "OUTRO", "LEAO", "WILD", "TRAPEZISTA", "ACROBATA", "LEAO", # ... 30 posições total ]

class WildTracking: def init(self): self.sticky_positions = {} # {reel_idx: [positions]}

def apply_sticky_wilds(self, current_reel_config):
    """
    Combina rolos atuais com wilds "pegados" do giro anterior
    """
    combined_config = []

    for reel_idx in range(5):
        reel = current_reel_config[reel_idx]

        # Verificar se há wild pegado neste rolo
        if reel_idx in self.sticky_positions:
            # Inserir wild nas posições pegadas
            for sticky_pos in self.sticky_positions[reel_idx]:
                reel[sticky_pos] = "WILD"

        combined_config.append(reel)

    return combined_config

def track_new_stickies(self, winning_wilds):
    """
    Após um giro vencedor com Wild, marca posições para próximo giro
    """
    for wild_pos in winning_wilds:
        reel_idx, pos = wild_pos
        if reel_idx not in self.sticky_positions:
            self.sticky_positions[reel_idx] = []
        self.sticky_positions[reel_idx].append(pos)

def reset_stickies(self):
    """Reseta wilds pegados entre bônus"""
    self.sticky_positions = {}

```

2. Expanding Multiplier Algorithm

2.1 Detecção de Expansão

```python class ExpandingWildLogic: def init(self): self.expansion_factors = {} # {symbol_id: expansion_count}

def calculate_wild_expansion(self, reel_config):
    """
    Para cada Wild na grade, verificar quantos símbolos iguais
    estão na mesma coluna (para expandir verticalmente)
    """
    expansions = {}

    for reel_idx in range(5):
        reel = reel_config[reel_idx]

        for pos in range(3):  # 3 linhas
            if reel[pos] == "WILD":
                # Encontrar qual símbolo este Wild está substituindo
                # (baseado em linhas de pagamento)
                symbol_beneath = self.get_symbol_beneath_wild(reel_idx, pos, reel_config)

                # Contar quantos deste símbolo existem na mesma linha
                count_in_line = sum(
                    1 for col in range(5)
                    if reel_config[col][pos] == symbol_beneath
                )

                # Expansão = quantidade de símbolos na linha
                if count_in_line >= 2:
                    key = (reel_idx, pos)
                    expansions[key] = count_in_line

    return expansions

def get_symbol_beneath_wild(self, reel_idx, line_idx, reel_config):
    """
    Determina qual símbolo o Wild está substituindo
    Baseado em análise de linha de pagamento
    """
    # Simplificado: assume Wild substitui símbolo mais frequente na linha
    symbols_in_line = [reel_config[col][line_idx] for col in range(5)]
    symbol_counts = {}
    for sym in symbols_in_line:
        if sym != "WILD":
            symbol_counts[sym] = symbol_counts.get(sym, 0) + 1

    return max(symbol_counts, key=symbol_counts.get) if symbol_counts else "OUTRO"

```

2.2 Aplicar Expansão ao Payout

```python def calculate_payout_with_expansion(winning_line, expansions): """ Calcula payout com multiplicador de expansão """ base_payout = PAYTABLE[winning_line['symbol']][winning_line['count']]

# Verificar se há expansão envolvida
expansion_multiplier = 1

for (reel_idx, pos), expansion_count in expansions.items():
    if (reel_idx, pos) in winning_line['positions']:
        expansion_multiplier = max(expansion_multiplier, expansion_count)

return base_payout * expansion_multiplier

```

3. Bonus Multiplier Accumulator

3.1 Bonus com Multiplicador Progressivo

```python class BonusSession: def init(self, num_spins=10): self.num_spins = num_spins self.spins_completed = 0 self.accumulated_multiplier = 1 self.total_win = 0

def process_bonus_spin(self, spin_result, expansions):
    """
    Processa um giro do bônus
    """
    self.spins_completed += 1

    # Calcular payout deste giro (com expansão)
    spin_payout = 0
    for winning_line in spin_result['winning_lines']:
        spin_payout += calculate_payout_with_expansion(winning_line, expansions)

    # Aplicar multiplicador acumulado
    final_spin_payout = spin_payout * self.accumulated_multiplier

    # Se há Wild expandido, aumentar multiplicador para próximo giro
    if any(expansions.values()):
        max_expansion = max(expansions.values())
        self.accumulated_multiplier = max_expansion

    self.total_win += final_spin_payout

    return {
        "spin_num": self.spins_completed,
        "base_payout": spin_payout,
        "accumulated_multiplier": self.accumulated_multiplier,
        "final_payout": final_spin_payout
    }

def is_bonus_complete(self):
    return self.spins_completed >= self.num_spins

```

4. Auto-Win Failsafe

4.1 Implementação da Garantia

```python def apply_auto_win_failsafe(final_bonus_win, target_rtp, base_bet): """ Se bônus não atingiu expected payout, garante mínimo """

# Calcular expected payout baseado em RTP
expected_payout = base_bet * target_rtp * 10  # 10 giros base aproximadamente

if final_bonus_win < expected_payout * 0.8:  # Se ficou 20% abaixo
    # Trigger failsafe
    shortfall = expected_payout * 0.8 - final_bonus_win

    # Criar giro extra garantido
    auto_win_spin = {
        "type": "auto_win_failsafe",
        "guaranteed_payout": shortfall,
        "reason": "RTP guarantee"
    }

    return final_bonus_win + shortfall, auto_win_spin

return final_bonus_win, None

```

5. Line Pay Calculation (20 Linhas)

5.1 Mapeamento de Linhas

```python PAYLINES = [ # Diagonal up [(0, 2), (1, 1), (2, 0), (3, 1), (4, 2)], # Linha 1 # Top [(0, 0), (1, 0), (2, 0), (3, 0), (4, 0)], # Linha 2 # Bottom [(0, 2), (1, 2), (2, 2), (3, 2), (4, 2)], # Linha 3 # Zigzag patterns [(0, 0), (1, 1), (2, 0), (3, 1), (4, 0)], # Linha 4 [(0, 2), (1, 1), (2, 2), (3, 1), (4, 2)], # Linha 5 # ... mais 15 linhas ]

def check_winning_lines(reel_config): """ Verifica qual linha paga """ winning_lines = []

for line_idx, payline in enumerate(PAYLINES):
    symbols_on_line = [
        reel_config[reel_idx][pos]
        for reel_idx, pos in payline
    ]

    # Verificar se é uma vitória (3+ símbolos iguais da esquerda)
    winning_symbol = None
    winning_count = 0

    for i, symbol in enumerate(symbols_on_line):
        if symbol in PAYABLE_SYMBOLS or symbol == "WILD":
            if winning_symbol is None:
                winning_symbol = symbol
            elif symbol == winning_symbol or symbol == "WILD" or winning_symbol == "WILD":
                winning_count += 1
            else:
                break  # Vitória encerrada

    if winning_count >= 2:  # 3+ símbolos (count começa em 0)
        winning_lines.append({
            "line": line_idx,
            "symbol": winning_symbol,
            "count": winning_count + 1,
            "positions": payline
        })

return winning_lines

```

6. JSON Payload

6.1 Spin Response

json { "spin_result": { "reel_config": [ ["ACROBATA", "LEAO", "WILD"], ["LEAO", "TRAPEZISTA", "ACROBATA"], ["WILD", "LEAO", "TRAPEZISTA"], ["ACROBATA", "WILD", "LEAO"], ["LEAO", "ACROBATA", "TRAPEZISTA"] ], "winning_lines": [ { "line": 0, "symbol": "LEAO", "count": 4, "payout": 40 } ], "expansions": { "[0, 2]": 2, // Wild em (0,2) expande para 2x "[2, 0]": 2 // Wild em (2,0) expande para 2x }, "expansion_adjusted_payout": 80, "sticky_wilds_for_next_spin": [[0, 2], [2, 0]], "bonus_triggered": false } }

6.2 Bonus Payload

json { "bonus_session": { "num_spins": 10, "spins": [ { "spin_num": 1, "base_payout": 50, "expansions": {"[1, 1]": 3}, "accumulated_multiplier": 1, "final_payout": 50 }, { "spin_num": 2, "base_payout": 25, "expansions": {}, "accumulated_multiplier": 3, "final_payout": 75 }, ... ], "total_bonus_win": 500, "failsafe_applied": false } }

7. RTP Validation

```python def validate_rtp_with_stickies(num_sessions=10000): """ Testa RTP considerando sticky wilds """ total_in = 0 total_out = 0

for _ in range(num_sessions):
    wager = 10.0
    spin_result = run_spin_with_sticky_tracking()

    total_in += wager
    total_out += spin_result.get('payout', 0)

observed_rtp = total_out / total_in
expected_rtp = 0.94

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

```

8. Hardware Requirements

• 60 FPS animation
• Sticky wild animation: 400ms
• Expansion animation: 500ms
• Total spin: 3-4 seconds

9. SAS 6.02 Integration

Events: - Game Round Start - Sticky Wild Tracked - Line Win - Bonus Start - Bonus Spin - Auto-Win Failsafe - Final Payout

Conclusão

O Grande Circo combina mecânicas familiares (20 linhas, Sticky Wilds) com twist moderno (Expanding Multipliers). Auto-Win Failsafe garante conformidade RTP mesmo em cenários edge-case.

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.