Bom dia meus caros leitores, finalmente, ontem finalizei a criação desse jogo que me acompanhou nas últimas seis semanas. O nome é Selva 2600, e ele é uma remontagem do Pitfall, o clássico que o David Crane fez para a Activision em 1982 e que rodava no Atari 2600. Comecei num sábado, 3 de outubro, e fui tocando à noite depois do expediente e nos fins de semana, até fechar a versão 1.0.5 neste domingo, 15 de novembro.

O Pitfall foi um dos jogos que mais joguei no Atari. Quem viveu aquela época lembra bem: o cartucho encaixado no console, o joystick de um botão só e aquele homenzinho correndo pela selva, pulando crocodilo e se pendurando no cipó, enquanto o cronômetro descia sem dó. Eu passava horas tentando chegar uma tela mais longe do que na vez anterior. Escolhi ele porque, olhando hoje com olhos de desenvolvedor, é um jogo que parece simples e não é: cabia num cartucho minúsculo, tinha um mundo enorme e regras que funcionam até hoje. Recriar o Pitfall era a desculpa perfeita para entender como tudo aquilo funcionava por dentro.

O nome e o personagem são meus. Todo o resto, eu me obriguei a seguir o original: o mesmo mundo de 255 telas na mesma ordem, os mesmos perigos, a mesma pontuação do manual de 1982. E isso, como vocês vão ver, deu bem mais trabalho do que inventar.

A stack é simples: Python, PyGame (na versão da comunidade, o pygame-ce) para a janela, o desenho e a entrada do teclado, e NumPy para gerar todos os sons na matemática, sem nenhum arquivo de áudio. No fim, PyInstaller para virar um .exe. Neste artigo eu conto cada etapa, com o código real do projeto, os números que guiaram as decisões e, principalmente, os bugs.

Um monolito modular, e não um arquivo de três mil linhas

Jogo em PyGame costuma nascer num arquivo só, com o laço principal, o personagem, o cenário e as colisões todos misturados. Funciona até a terceira mecânica. Eu quis o contrário desde o primeiro dia: um único programa, mas separado em módulos com responsabilidade clara. No fim, ficaram cerca de 2.900 linhas de Python, divididas assim:

selva2600/
├── executar.py              # ponto de entrada (também o do .exe)
├── selva2600.spec           # configuração do PyInstaller
└── codigo/selva/
    ├── configuracao.py      # resolução lógica, paleta, versão
    ├── principal.py         # prepara DPI, áudio e ícone; inicia o jogo
    ├── jogo.py              # laço principal, estados e colisões
    ├── jogador.py           # o explorador
    ├── cenario.py           # as 255 telas, geradas byte a byte
    ├── placar.py            # pontos, vidas e cronômetro
    ├── sons.py              # todos os sons, gerados com NumPy
    ├── tela_titulo.py       # telas de início e de fim de jogo
    ├── manual.py            # manual do usuário (F10)
    ├── entidades/           # buraco, escada, lago, crocodilo, cipó, tora...
    └── utilitarios/         # janela, sprites, formas, ícone, caminhos

A regra prática que segurou o projeto inteiro: tudo que aparece na tela e tem comportamento próprio vira uma classe em entidades/, com um atualizar() e um desenhar(). São 12 entidades, do buraco ao escorpião. O jogo.py não sabe como um crocodilo abre a boca; ele só pergunta se o explorador está em cima de algo que sustenta.

Uma tela de 1982 em monitores de hoje

O Atari 2600 desenhava 192 linhas na TV. Eu mantive essa altura e abri a largura para 256, e o jogo inteiro é desenhado numa superfície pequena de 256×192 pixels. Só no último momento de cada quadro essa superfície é ampliada para o tamanho da janela.

def apresentar(self, sobreposicao=None):
    # scale (sem suavização) preserva o visual de pixel do Atari
    pygame.transform.scale(self.superficie, self.janela.get_size(), self.janela)
    if sobreposicao:
        sobreposicao(self.janela)
    pygame.display.flip()

Repara no scale em vez do smoothscale. O primeiro só repete pixels, e é isso que mantém os blocos nítidos. O segundo suaviza as bordas, e o jogo vira uma foto borrada de um Atari. O parâmetro sobreposicao apareceu bem depois, e eu volto nele na parte das telas de início e do manual.

A janela abre com 85% do monitor e se adapta a qualquer tamanho, sem faixas pretas; F11 alterna para tela cheia. No Windows teve um detalhe: com escala de exibição em 125% ou 150%, o sistema mente a resolução para o programa e amplia a janela por conta própria, deixando tudo borrado. A saída é avisar o Windows, antes do pygame.init(), que o jogo cuida do DPI sozinho, com ctypes.windll.shcore.SetProcessDpiAwareness(2).

Desenhando sem um único arquivo de imagem

Não existe nenhum PNG no projeto, a não ser o ícone. Cada personagem é uma grade de letras dentro do próprio código, e cada letra é uma cor da paleta. O explorador parado é isto:

GRADE_PARADO = [
    "..HHHH..",   # H = capacete
    ".HHHHHH.",
    "..PPPP..",   # P = pele
    "..PPPP..",
    "...PP...",
    ".CCCCCC.",   # C = camisa
    "PCCCCCCP",
    # ... mais 11 linhas: calça (A) e botas (B)
]

E uma função de quinze linhas transforma a grade em imagem do PyGame, deixando transparente tudo que não está na paleta:

def criar_sprite(grade, paleta):
    largura = len(grade[0])
    altura = len(grade)
    imagem = pygame.Surface((largura, altura), pygame.SRCALPHA)
    for y, linha in enumerate(grade):
        for x, letra in enumerate(linha):
            if letra in paleta:
                imagem.set_at((x, y), paleta[letra])
    return imagem

Parece pouco, mas muda o jeito de trabalhar. Ajustar a perna da animação de corrida é editar um caractere, e o desenho virado para a esquerda sai de graça com pygame.transform.flip. O explorador tem 8×18 pixels; os 8 de largura não são por acaso, é a largura de um sprite de jogador no Atari 2600.

O pulo que virou a régua do jogo

A física do explorador cabe em duas constantes, medidas em pixels por quadro, a 60 quadros por segundo: o pulo sai com velocidade de 2,6 para cima e a gravidade soma 0,15 a cada quadro. Com esses dois números, o explorador fica 34 quadros no ar e sobe no máximo 22,5 pixels. Correndo a 1 pixel por quadro, o pulo cobre 34 pixels de chão.

Esse 34 virou a unidade de medida de todo o resto. O piche tem 96 pixels de largura justamente para ser impossível de pular. O túnel tem altura para o pulo caber sem a cabeça bater no teto. E foi esse mesmo número que, mais à frente, deixou os crocodilos impossíveis de atravessar.

Um detalhe que custa uma linha e muda a sensação do jogo: o pulo exige soltar a tecla. Sem isso, segurar o espaço vira um pula-pula infinito, e o jogador perde a precisão que o Pitfall pede.

255 telas guardadas em um único byte

Essa é a parte mais bonita do original, e a que mais me fez estudar. O Pitfall tem 255 telas, e nenhuma delas está guardada no cartucho. O jogo guarda só um byte, o da tela atual. Para andar uma tela para a direita, ele aplica uma conta nesse byte e obtém o da próxima. Para a esquerda, a conta inversa.

A conta é um registrador de deslocamento com realimentação, o famoso LFSR. O byte inicial é C4 em hexadecimal; a cada passo, os bits andam uma casa para a esquerda e o bit 0 recebe o XOR dos bits 3, 4, 5 e 7. No Selva 2600 ficou assim:

BYTE_INICIAL = 0xC4

def proximo_byte(byte):
    """Contador do original, indo para a direita: desloca e realimenta os bits 3, 4, 5 e 7."""
    bit = ((byte >> 3) ^ (byte >> 4) ^ (byte >> 5) ^ (byte >> 7)) & 1
    return ((byte << 1) | bit) & 0xFF

E cada pedaço do byte decide uma coisa da tela:

Bits O que decidem Valores
0 a 2 O objeto da tela 1, 2 ou 3 toras rolando, 1 ou 3 toras paradas, fogueira ou cobra (e o tipo de tesouro, nas telas que têm)
3 a 5 O tipo de cena buraco com escada, três buracos, piche, pântano, crocodilos, piche que abre e fecha com tesouro, piche que abre e fecha com cipó, areia movediça
6 e 7 O desenho das árvores quatro arranjos; o bit 7 também escolhe o lado da parede no túnel

Quando eu gerei as 255 telas e contei, apareceu um detalhe que eu achei elegante. Cada um dos 8 tipos de cena aparece em 32 telas, menos o primeiro, que aparece em 31. A explicação é que esse contador nunca passa pelo zero: são 255 bytes possíveis, e não 256. E o tipo "piche com tesouro" dá exatamente 32 telas, que são os 32 tesouros do jogo. Ninguém escolheu um número de tesouros; ele saiu da conta.

O túnel usa a mesma conta. Andar uma tela por baixo da terra equivale a aplicar o passo três vezes, ou seja, cada tela do túnel vale por três da superfície. É o atalho do jogo, com um preço: nas telas com escada, uma parede de tijolos bloqueia um dos lados.

Quando eu tentei inventar, o jogo cobrou

Confesso que não comecei assim. A primeira versão do mundo usava random.Random(indice) com probabilidades escolhidas por mim, e por algumas fases funcionou. Até eu perceber que o piche aparecia em só 9 das 255 telas, que buraco comum dominava a selva e que eu tinha feito buraco matar, quando no original ele só derruba você no túnel e tira 100 pontos.

Troquei tudo pela tabela do byte original de uma vez, e o equilíbrio do jogo apareceu sozinho. A regra que eu levo daqui: fidelidade ao original não é nostalgia, é game design que já foi testado por muita gente antes de você.

Crocodilos, cipó e a matemática do perigo
 

Os crocodilos e os 2 pixels que faltavam

No primeiro desenho, os crocodilos ficavam a 32 pixels um do outro. O pulo, como vimos, cobre 34. Na prática, cada salto deixava o explorador 2 pixels mais perto da boca do crocodilo seguinte. Para atravessar em segurança mesmo se a boca abrisse no meio do caminho, sobrava uma janela de só 4 pixels no ponto de partida. No teclado, isso é sorte.

A correção foi igualar a distância ao alcance do pulo e dar mais tempo de boca fechada:

ESPACO_ENTRE_CROCODILOS = 34   # igual ao alcance do pulo correndo
QUADROS_FECHADA = 210          # 3,5 s de boca fechada
QUADROS_ABERTA = 90            # 1,5 s de boca aberta
LARGURA_BOCA = 8               # com a boca aberta, só a parte de trás da cabeça é apoio

Agora cada salto cai exatamente no mesmo ponto da cabeça seguinte, e a janela segura de partida dobrou para 8 pixels. Continua exigindo atenção, que é o espírito do original, mas deixou de exigir sorte.

O cipó é um pêndulo de verdade

O cipó não é animação pronta. A ponta segue a fórmula de um pêndulo, com o ângulo variando em seno ao longo do tempo:

@property
def angulo(self):
    fase = 2 * math.pi * self.contador / PERIODO        # PERIODO = 240 quadros (4 s)
    return math.radians(ANGULO_MAXIMO) * math.sin(fase)  # ANGULO_MAXIMO = 50°

@property
def ponta(self):
    angulo = self.angulo
    return (
        self.x_preso + COMPRIMENTO * math.sin(angulo),   # COMPRIMENTO = 64 px
        self.y_preso + COMPRIMENTO * math.cos(angulo),
    )

O explorador agarra quando as mãos encostam na ponta durante um pulo, e solta apertando o pulo de novo, saindo na direção em que o cipó está indo. Simulando todos os momentos possíveis do balanço, a janela para agarrar ficou em cerca de 0,8 segundo por ciclo, e a janela para soltar e chegar do outro lado, em cerca de meio segundo. Soltou cedo, caiu no piche.

Piche e areia que abrem e fecham

O piche e a areia movediça variáveis seguem um ciclo: 1,5 s fechados, 1 s abrindo, 1,5 s abertos e 1 s fechando. Só são perigosos enquanto estão visíveis, e a área de perigo acompanha a largura do momento. Na primeira versão eram retângulos, e ficou horrível. Hoje são ovais desenhados em degraus de 2 pixels, com uma superelipse de expoente 3, que deixa o meio cheio e as pontas arredondadas sem parecer um losango.

Os bugs que só aparecem jogando

Teste de unidade não pega "o boneco ficou preso". Os piores bugs do Selva 2600 só apareceram com alguém jogando, e dois deles valem o registro.

O explorador preso entre duas toras paradas

Algumas telas têm três toras paradas, a 20 pixels uma da outra. Cada tora tem 8 de largura, então sobra um vão de 12 pixels entre elas. Ao mesmo tempo, encostar numa tora fazia o explorador tropeçar e ficar 40 quadros piscando, sem controle.

Juntando as duas coisas: se o explorador caía no vão, qualquer tentativa de sair para um lado ou para o outro esbarrava numa tora e travava de novo. E não havia espaço para tomar distância e pular. Na tela, o jogador via um boneco piscando que não obedecia a nada.

Fui ao manual original, e ele fala em perda de pontos pelas toras, sem prender ninguém. A correção foi fazer só a tora rolando derrubar; a parada continua tirando pontos, mas deixa passar:

tocadas = []
if jogador.cipo is None:
    tocadas = [t for t in self.cenario.toras if area_contato.colliderect(t.retangulo)]
tocando = bool(tocadas)
tocando_rolando = any(tora.rolando for tora in tocadas)
comecou_a_tocar = tocando_rolando and not self.tocando_tora
self.tocando_tora = tocando_rolando
if tocando:
    self.placar.perder(PERDA_TORA_POR_QUADRO)
if comecou_a_tocar and jogador.no_chao and not jogador.tropecando:
    jogador.tropecar()

Repara também no jogador.cipo is None na segunda linha. Esse é o segundo bug: no ponto mais baixo do balanço, os pés do explorador chegam à altura do chão, e toda tora que passava embaixo tirava pontos de quem estava pendurado. Pendurado no cipó, agora, as toras passam por baixo.

Milhares de partidas sem abrir a janela

Para não depender só de jogar, eu passei a rodar partidas simuladas. O SDL aceita um driver de vídeo falso, e o jogo roda inteiro sem janela; daí é só apertar teclas aleatórias, quadro a quadro, e procurar estados impossíveis.

SDL_VIDEODRIVER=dummy SDL_AUDIODRIVER=dummy python3 testes_partidas.py

O critério de travamento é simples: uma seta apertada e a posição do explorador parada por mais de quatro segundos. Numa rodada dessas, com três partidas por tela nas 255 telas, saíram 765 partidas sem erro e sem travamento. Foi esse tipo de teste que confirmou as correções acima.

E uma lição menor, mas que me custou caro: em algum momento eu tirei o número da tela do canto superior direito, porque era "provisório". Na hora de reproduzir um bug, eu não sabia em que tela estava. Voltou e ficou. Informação de depuração que ajuda o jogador a te reportar um bug não é provisória.

Som feito de matemática com NumPy

Desde o começo a regra era: nenhum arquivo de áudio. O chip de som do Atari, o TIA, gerava tudo a partir de formas de onda simples, entre elas tons quadrados e ruído, e foram essas duas que eu usei. Tudo é gerado com NumPy uma única vez, quando o jogo abre, e guardado como pygame.mixer.Sound.

O truque para fazer um som que muda de tom, como o pulo que sobe, é acumular a fase em vez de calcular o seno de uma frequência fixa:

def _quadrada(frequencias):
    """Onda quadrada que acompanha uma frequência que pode variar a cada amostra."""
    fase = np.cumsum(frequencias) / TAXA_AMOSTRAGEM
    return np.where((fase % 1.0) < 0.5, 1.0, -1.0)

def _varredura(tom_inicial, tom_final, duracao):
    """Tom que desliza de uma frequência a outra (escala exponencial, como o ouvido percebe)."""
    t = _tempo(duracao)
    frequencias = tom_inicial * (tom_final / tom_inicial) ** (t / duracao)
    return _envelope(_quadrada(frequencias))

O np.cumsum soma, amostra por amostra, quanto do ciclo já andou. Assim a frequência pode mudar a cada amostra sem a onda dar saltos. A variação é exponencial, e não linear, porque o ouvido percebe tom em escala logarítmica: de 300 para 600 Hz soa como o mesmo salto que de 600 para 1.200. O _envelope sobe e desce o volume nas pontas por alguns milissegundos, e é o que tira aquele estalo de som cortado.

O ruído das toras é ainda mais simples: valores aleatórios entre -1 e 1, cada um repetido por 90 amostras, o que derruba a frequência e vira um ronco grave. No fim, tudo vira inteiro de 16 bits e entra no mixer:

amostras = (onda * VOLUME * 32767).astype(np.int16)
if canais > 1:
    amostras = np.repeat(amostras[:, np.newaxis], canais, axis=1)
return pygame.sndarray.make_sound(np.ascontiguousarray(amostras))
Momento Som Duração
Pulo onda quadrada subindo de 300 para 900 Hz 0,12 s
Queda no buraco onda quadrada descendo de 700 para 90 Hz 0,55 s
Contato com tora ruído grave em repetição, enquanto encostar 0,25 s por volta
Tesouro fanfarra curta subindo 0,64 s
Agarrar o cipó três subidas de tom e uma nota longa com vibrato 1,26 s
Morte fanfarra descendo 1,92 s

Aqui teve uma decisão consciente. No original, três desses sons são trechos de obras protegidas: o grito do Tarzan no cipó, as notas do tema de Dragnet na morte e a fanfarra Charge! no tesouro, segundo o VGMPF. Em vez de copiar, compus melodias próprias, com a mesma função e duração parecida.

Um cuidado final: sem placa de som, pygame.mixer.get_init() devolve None, e o jogo segue em silêncio em vez de quebrar.

Pontos, vidas e o manual de 1982

As regras de pontuação saíram direto do manual original:

  • O jogo começa com 2.000 pontos, 3 vidas e 20 minutos.
  • São 32 tesouros, 8 de cada tipo: saco de dinheiro (2.000), barra de prata (3.000), barra de ouro (4.000) e anel de diamante (5.000).
  • Cair num buraco tira 100 pontos; encostar numa tora tira pontos enquanto durar o contato.
  • Ao perder uma vida, o explorador reaparece caindo das árvores, do lado esquerdo.
  • O jogo acaba na terceira vida perdida ou quando o tempo zera. A pontuação máxima é 114.000.

Onde o manual não diz, eu decidi e deixei registrado. Ele não informa quantos pontos a tora tira por segundo; no Selva 2600 é 1 ponto por quadro, ou seja, 60 por segundo. E o placar nunca fica negativo.

Tela de início, fim de jogo e um manual dentro do jogo

Com o jogo funcionando, faltava a vitrine. A tela de início mostra a selva da primeira tela, o explorador, uma tora rolando, o nome do jogo e os créditos com o link para o site, clicável. E aí veio o problema: texto pequeno a 256×192, depois de ampliado, fica ilegível. A versão 1.0.5 aparecia como 1.05, porque o primeiro ponto sumia, e "F10" parecia "FIO".

A solução foi aquele parâmetro sobreposicao do apresentar(). O título grande e a cena continuam em pixel de Atari, desenhados na resolução lógica. Os textos pequenos são escritos depois da ampliação, direto na resolução da janela, com uma fonte proporcional à altura dela. Ficam nítidos em qualquer monitor, e o clique no link é testado nas coordenadas reais do mouse.

A tela de fim de jogo reaproveita a mesma cena, convertida em tons de cinza com pygame.transform.grayscale (recurso do pygame-ce), e só os textos ficam coloridos: pontos, tesouros recolhidos e "ENTER PARA O INÍCIO".

Por último, o manual do usuário, que abre com F10 na tela de início: cinco páginas com objetivo, controles, perigos, tesouros e dicas. Um detalhe bobo que me pegou: a fonte padrão do PyGame informa que tem as setas ← e →, mas desenha um quadradinho no lugar. As teclas ficaram escritas por extenso, como "Seta para cima".

Do script ao executável

O objetivo final era um .exe que rodasse em qualquer Windows sem Python instalado. O PyInstaller resolve isso com um arquivo de configuração: arquivo único, sem janela de terminal e com ícone. Deixei a compressão UPX desligada, porque executável comprimido costuma disparar alarme falso em antivírus. E vale lembrar que o PyInstaller só gera executável para o sistema em que está rodando: o .exe precisa ser gerado no Windows.

Os passos, no PowerShell, são estes (em casa, o pip install vai direto ao PyPI; em rede corporativa, aponte para o espelho interno da empresa):

py -3.12 -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements.txt
.\.venv\Scripts\python.exe -m codigo.selva.utilitarios.icone
.\.venv\Scripts\python.exe -m PyInstaller --noconfirm --clean selva2600.spec

O ícone é o próprio explorador, em pé sobre o chão da selva, gerado a partir da mesma grade de letras do jogo. Para não adicionar o Pillow só por causa disso, o .ico é montado na mão: um .ico moderno aceita imagens PNG dentro dele, então basta um cabeçalho e uma entrada de 16 bytes para cada tamanho.

imagens = [(tamanho, _png(criar_icone(tamanho))) for tamanho in TAMANHOS_ICO]
cabecalho = struct.pack("<HHH", 0, 1, len(imagens))
deslocamento = len(cabecalho) + 16 * len(imagens)
entradas = b""
for tamanho, png in imagens:
    lado = 0 if tamanho >= 256 else tamanho  # 0 significa 256 no formato .ico
    entradas += struct.pack("<BBBBHHII", lado, lado, 0, 0, 1, 32, len(png), deslocamento)
    deslocamento += len(png)

São sete tamanhos, de 16 a 256 pixels. O mesmo desenho também vira o ícone da janela, com pygame.display.set_icon, chamado antes de a janela ser criada.

Pra fechar

Seis semanas depois, o que mais me marcou foi perceber o tamanho do trabalho que cabia num cartucho do Atari. Cada mecânica que eu fui implementar já tinha uma resposta melhor no original, e quase sempre era mais simples do que a minha primeira ideia. O byte que gera o mundo inteiro é o exemplo mais claro.

Do lado técnico, ficam três lições. Desenhar numa resolução lógica pequena e ampliar só no fim resolve o problema dos monitores de uma vez. NumPy gera som com pouquíssimo código, desde que você pense em amostras e fase, e não em notas. E nenhum teste substitui alguém jogando, mas milhares de partidas simuladas encontram o que o jogador ainda não reclamou.

O próximo desafio já está escolhido: fazer a mesma coisa com o Montezuma's Revenge. Só que lá o mundo não cabe num byte.

Fontes: