Algoritmos Pseudoaleatórios

Eventos aleattórios em jogos MOBA introduzem imprevisibilidade, mas podem distorcer a avaliação da habilidade dos jogadores. Para equilibrar isso, a distribuição pseudoaleatória (PRD) ajusta dinamicamente as probabilidades. Cada ocorrência malsucedida aumenta a chance futura, enquanto sucessos redefinem o contador.

Considere uma habilidade com 25% de chance crítica. Na PRD, a probabilidade inicial pode ser 8.5%, aumentando incrementalmente a cada tentativa fracassada. Após três ataques sem crítico, a probabilidade atinge ~25.5%. Após o acerto, o ciclo reinicia.

Implementação com Cadeias de Markov

A lógica segue princípios de Cadeias de Markov, onde a probabilidade depende apenas do estado atual. Para uma habilidade com probabilidade alvo P, calculamos o incremento constante C usando busca binária:

import math

def calcular_probabilidade_por_incremento(incremento):
    prob_acumulada = 0
    soma_tentativas = 0
    tentativas_max = math.ceil(1 / incremento)
    
    for tentativa in range(1, tentativas_max + 1):
        prob_instantanea = min(1, incremento * tentativa) * (1 - prob_acumulada)
        prob_acumulada += prob_instantanea
        soma_tentativas += tentativa * prob_instantanea
        
    return 1 / soma_tentativas

def calcular_incremento_por_probabilidade(prob_alvo):
    limite_superior = prob_alvo
    limite_inferior = 0.0
    prob_anterior = 1
    
    while True:
        incremento_medio = (limite_superior + limite_inferior) / 2
        prob_atual = calcular_probabilidade_por_incremento(incremento_medio)
        
        if abs(prob_atual - prob_anterior) < 1e-9:
            break
            
        if prob_atual > prob_alvo:
            limite_superior = incremento_medio
        else:
            limite_inferior = incremento_medio
            
        prob_anterior = prob_atual
        
    return incremento_medio

Uso prático para uma habilidade de 20% de chance crítica:

incremento_base = calcular_incremento_por_probabilidade(0.20)

for tentativas_sem_acerto in range(1, 4):
    chance_efetiva = incremento_base * 100 * tentativas_sem_acerto
    print(f"Tentativa {tentativas_sem_acerto}: {chance_efetiva:.2f}%")

Aleatoriedade Verdadeira

Em contraste, aleatoiredade verdadeira não mantém correlação entre eventos consecutivos. Computadores implementam isso via geradores pseudoaleatórios que simulam independência estatística:

from collections import Counter
import random

frequencias = Counter()
for _ in range(10000):
    numero_sorteado = random.randint(1, 100)
    frequencias[numero_sorteado] += 1

print(frequencias.most_common(5))

Este código gera distribuição aproximadamente uniforme, com frequências variando naturalmente. Contudo, sistemas computacionais são deterministicos - a "aleatoriedade" deriva de algoritmos complexos que emulam propriedades estatísticas de processos verdadeiramente aleatórios.

Limitações Práticas

Comparando com um gerador não-aleeatório:

frequencias_fixas = Counter()
for _ in range(10000):
    frequencias_fixas[100] += 1  # Sem variação

Verifica-se que a dispersão máxima (ex: 123 ocorrências de um valor) indica aleatoriedade, enquanto distribuição perfeita (10000 ocorrências) denota determinismo.