No post anterior eu terminei prometendo o texto sobre duplicatas. Sentei para escrever e travei na terceira linha, por um motivo que vou registrar aqui porque é o problema inteiro deste projeto resumido em uma frase: eu não consigo comparar a versão da Steam com a versão da Epic se eu não souber antes onde cada uma delas mora.
Onde a série estava
O post 1 resolveu a posse: o CSV saiu do LaunchBox, cada linha sabendo de onde veio. O post 2 resolveu o uso: a Steam devolve horas, as outras cinco não devolvem nada, e essa assimetria virou a tese da série.
Ficaram pendentes quatro colunas vazias. Duas eu resolvi. E foi ao atacar a terceira — GrupoDuplicata — que tudo parou.
Porque a pergunta "qual das três versões de Batman é a boa" pressupõe que as três estejam na mesma página. E para estarem na mesma página, elas precisam estar no mesmo corte. O corte vem antes de tudo. Não é organização prévia, é condição de existência do problema seguinte.
Por que não por loja, e por que a intuição estava certa
A primeira ideia que eu tive foi a mais óbvia: dividir por loja. Um post por loja, por mês, algo assim.
Aí eu olhei os números reais da planilha.
| Origem | Jogos | Como chegaram |
|---|---|---|
| Epic | 549 | Resgate semanal gratuito |
| GOG | 408 | Prime Gaming e resgates |
| Steam | 320 | Compra, na maioria |
| Amazon | 277 | Assinatura Prime |
| Windows (sem loja identificada) | 74 | A resolver pelo caminho |
| EA | 10 | Resgate |
| Uplay | 11 | Resgate |
| Total | 1.606 |
Dividir por loja significa vinte e sete posts seguidos sobre jogos da Epic. Vinte e sete textos onde a única coisa em comum entre os jogos é o fato de terem sido resgatados de graça, na mesma plataforma, por motivos que não têm nada a ver uns com os outros.
A loja não é uma categoria do jogo. É uma categoria da sua relação com o jogo, e ela é a mais pobre de todas — porque foi decidida por um algoritmo de desconto, não por você.
A loja não diz nada sobre o jogo. Só diz por onde ele entrou em você.
Por que o alfabético também não serve
A segunda ideia foi a ordem alfabética, e eu gostei dela por um motivo honesto: parecia aleatória.
Não é. Ordenar por título agrupa exatamente o que eu queria evitar.
Todas as franquias caem juntas. Todos os Call of Duty, todos os Need for Speed, todos os Batman. E depois de remover os artigos — The, A, An, O, Os, As — ainda sobra outro agrupamento: as franquias com prefixo numérico e as séries que compartilham a primeira palavra. O alfabeto é um agrupador silencioso, e ele é pior que a loja porque é menos óbvio.
Um bloco alfabético de vinte jogos não é uma amostra da biblioteca. É um recorte de uma prateleira.
E por que não por data
A ordem cronológica seria a melhor de todas, e é a única que eu não tenho.
A data de aquisição não está no CSV, porque o LaunchBox nunca foi usado como launcher — ele foi usado como verificador de compra. Os jogos entraram nele quando eu abri a promoção, não quando eu comprei o jogo. A data que existe é a data em que eu catalogou, e ela não serve para nada neste problema.
Seria possível reconstruir isso da Steam pela API e do GOG pelo banco local. Mas 549 jogos da Epic continuariam sem data, e um corte que cobre dois terços da biblioteca é pior que um corte que cobre tudo.
Eu queria cortar por biografia. Tive que cortar por matemática.
O hash
A solução é calcular o MD5 do título normalizado de cada jogo e ordenar por esse valor.
Normalizar significa: minúsculas, sem acentos, sem pontuação, sem parênteses, sem artigos no começo. O MD5 é a mesma função que eu usei no post do RetroAchievements — aquela que decide se o seu arquivo existe ou não —, só que aplicada a texto em vez de bytes.
E o resultado é o que eu queria desde o começo: uma ordem que não significa nada. Nenhum agrupamento por franquia, por loja, por gênero, por época. Cada bloco de vinte vira uma amostra verdadeiramente aleatória da biblioteca.
Tem uma coisa nisso que me agrada mais do que devia. A mesma função que decidiu, em outubro, se o meu arquivo existia para o RetroAchievements agora decide em que post cada jogo vai cair. Não foi escolha estética — foi a ferramenta que resolveu, duas vezes, problemas que pareciam sem solução.
O hash não sabe qual jogo é bom. Ele sabe que dois arquivos diferentes são coisas diferentes. Numa biblioteca de mil e seiscentos, isso é a única coisa que eu preciso que ele saiba.
O efeito colateral que virou o método
Quando eu vi o primeiro bloco pronto, entendi que o hash não resolveu apenas o corte. Ele criou um mecanismo de descoberta.
Uma recomendação de algoritmo faz uma coisa específica: ela te devolve mais do que você já gosta. A Steam olha o que você jogou e sugere parecido. O resultado é convergência — você afunila, joga mais do mesmo, e a biblioteca fica cada vez mais homogênea em uso.
O hash faz o oposto. Ele te devolve o que você esqueceu. Não o que você gosta hoje — o que você quis no passado. Um jogo que você resgatou em 2019 porque achou interessante na época, quando você era uma pessoa ligeiramente diferente, e que nunca abriu.
E é por isso que ele serve para achar pérola: porque pérola não é um jogo bom. É um jogo que você quis e abandonou antes de começar.
Juntando os dois lados: um bloco de vinte jogos aleatórios tem, estatisticamente, de três a cinco jogos que você não lembra de ter. Em oitenta blocos, isso são duzentos e cinquenta jogos que voltam a existir. Nenhuma loja vai te recomendar esses, porque eles não geram receita. Só um inventário encontra o que não vende mais.
O problema que eu tinha deixado para depois: a biblioteca é viva
Aqui está a parte que qualquer sistema de organização de biblioteca ignora e que me obrigou a repensar o desenho inteiro.
Se eu cortar 1.606 jogos em 80 blocos hoje, em janeiro o número não será mais 1.606. A Epic dá de quatro a cinco jogos grátis por semana. O Prime entrega entre vinte e trinta por mês. E toda promoção boa demais para ignorar — como a de Halloween, sete itens por trinta e dois reais — coloca mais coisa dentro.
Isso significa talvez quatrocentos ou quinhentos jogos novos por ano. Vinte a vinte e cinco blocos a mais, só de crescimento.
Se os blocos fossem recalculados toda vez, todos os posts já escritos ficariam errados. Se os jogos novos fossem jogados para o bloco que o hash deles indica, eles cairiam em blocos já publicados, e eu teria que emendar posts do passado.
Nenhuma das duas funciona. A saída é separar em duas coisas que não são a mesma.
Congelar o acervo, abrir a cauda
Os 1.606 jogos que existem hoje — ou melhor, no dia 26 de outubro de 2026 — são o acervo. Eles recebem os blocos de 1 a 81 e esses números não mudam nunca mais. É arqueologia: a biblioteca como ela era, fotografada num dia.
Tudo que chegar depois entra na cauda, e os blocos da cauda começam no 82 e sobem. Não é ordem alfabética nem hash — é ordem de chegada. É diário.
E aqui está a parte que eu não esperava e que faz o projeto inteiro valer a pena: a série muda de natureza sozinha.
Os primeiros oitenta e um blocos são sobre quem eu fui — a biblioteca acumulada em quinze anos de resgate automático. Do octogésimo segundo em diante, cada bloco é sobre o que acabou de acontecer comigo naquela semana. É o mesmo formato, mas o tempo muda de direção.
Os sete itens da promoção de Halloween já nasceram na cauda. O post que eu escrevi sobre eles não é o post 3 nem o 4 — é o primeiro registro da cauda, escrito antes de eu saber que a cauda existia.
Os primeiros oitenta blocos olham para trás. Depois deles, a série começa a olhar para o lado.
A Fila, que não é uma aba
Sobre a ideia de separar em abas — jogos com conquista numa, sem conquista na outra — eu mudei de opinião, e o motivo é mecânico.
Aba é amputação. Filtro é lente.
No momento em que eu movo 900 jogos para uma aba "sem conquistas", eu perco a única coisa que este projeto tem de mais valioso: a comparação entre o que é mensurável e o que não é. A assimetria entre as lojas — que é a tese do post 2 — deixa de ser visível quando eu separo. Separar é aceitar que são duas coisas diferentes, e o ponto é justamente que são a mesma biblioteca com tratamentos desiguais.
Tem também o problema braçal: cada vez que um status de conquista muda, o jogo precisa mudar de aba. Manual, em 1.606 linhas, é erro garantido.
O que eu vou fazer é o inverso. Uma planilha mestra, editada só por mim, e duas abas geradas por script a partir dela. Elas não são digitadas — são calculadas. Se der errado, eu apago e rodo de novo.
A primeira é a Fila: os candidatos a virar o jogo da semana. Entram só os que têm conquista disponível, estão parados ou nunca abertos, e não foram marcados como "nunca". A ordenação é por custo de fechar — quanto mais perto do fim, mais alto. Isso é diminuição de backlog com o menor esforço possível, que é o único tipo de backlog que se resolve na vida adulta.
A segunda é a Pérolas: vinte jogos por mês, sorteados por hash sobre o acervo, filtrados por "nunca aberto e você quis jogar". Roda todo mês e nunca repete o mesmo conjunto. É a minha resposta à pergunta de como achar pérola em 1.606 jogos: não procurando. Amostrando, todo mês, para sempre.
O script
Três coisas ele faz: calcula o hash, distribui os blocos com o congelamento, e escreve a planilha com as duas abas derivadas.
import csv, re, hashlib, unicodedata, sys
from datetime import datetime
ARQ_ENTRADA = "biblioteca_launchbox_2026-10-26.csv"
ARQ_MESTRE = "biblioteca_mestra.csv"
ARQ_XLSX = "biblioteca.xlsx"
DATA_CORTE = datetime(2026, 10, 26).date()
TAM_BLOCO = 20
ARTIGOS = {"the","a","an","o","os","as","um","uma",
"le","la","les","el","los","der","die","das"}
def normalizar(t):
t = unicodedata.normalize("NFKD", (t or "").lower())
t = "".join(c for c in t if not unicodedata.combining(c))
t = re.sub(r"[™®©]", " ", t)
t = re.sub(r"\s*[\(\[].*?[\)\]]", " ", t)
t = re.sub(r"[^a-z0-9 ]", " ", t)
p = [x for x in t.split() if x]
while p and p[0] in ARTIGOS:
p.pop(0)
return " ".join(p)
def chave(titulo):
return hashlib.md5(normalizar(titulo).encode("utf-8")).hexdigest()
def data_entrada(linha):
for campo in ("DataEntrada", "DataAquisicao", "Added", "DateAdded"):
v = (linha.get(campo) or "").strip()
if not v:
continue
for fmt in ("%Y-%m-%d", "%d/%m/%Y", "%Y-%m-%dT%H:%M:%S"):
try:
return datetime.strptime(v[:19], fmt).date()
except ValueError:
pass
return None
def numero(v):
try:
return float(str(v).replace("%", "").replace(",", "."))
except (TypeError, ValueError):
return None
with open(ARQ_ENTRADA, encoding="utf-8-sig") as fh:
linhas = list(csv.DictReader(fh, delimiter=";"))
if not linhas:
sys.exit("CSV vazio ou separador errado.")
for l in linhas:
l["_data"] = data_entrada(l)
l["_chave"] = chave(l.get("Titulo"))
l.setdefault("Status", "")
l.setdefault("TemConquistas", "")
l.setdefault("PctConquistas", "")
l.setdefault("Intencao", "")
# acervo = fotografado hoje | cauda = chegou depois
acervo = [l for l in linhas if l["_data"] is None or l["_data"] <= DATA_CORTE]
cauda = [l for l in linhas if l["_data"] is not None and l["_data"] > DATA_CORTE]
# hash, com desempate deterministico para variantes do mesmo jogo
ORDEM = lambda l: (l["_chave"], (l.get("Loja") or ""), (l.get("Titulo") or ""))
acervo.sort(key=ORDEM)
cauda.sort(key=ORDEM)
def numerar(grupo, inicio):
for i, l in enumerate(grupo):
l["Bloco"] = str(inicio + i // TAM_BLOCO)
numerar(acervo, 1)
ultimo = 1 + (len(acervo) - 1) // TAM_BLOCO if acervo else 0
numerar(cauda, ultimo + 1)
# ---------- aba Fila: candidatos ao jogo da semana ----------
fila = []
for l in acervo + cauda:
if (l.get("TemConquistas") or "").strip().lower() != "sim":
continue
st = (l.get("Status") or "").strip().lower()
if st not in ("nunca aberto", "parado"):
continue
if (l.get("Intencao") or "").strip().lower() == "nunca":
continue
pct = numero(l.get("PctConquistas")) or 0.0
l["CustoFechar"] = round(100 - pct, 1) if st == "parado" else 150.0
fila.append(l)
fila.sort(key=lambda l: (l["CustoFechar"], int(l["Bloco"])))
# ---------- aba Perolas: 20 por mes, rotativas ----------
MES = datetime.now().strftime("%Y-%m")
perolas = [
l for l in acervo
if (l.get("Status") or "").strip().lower() == "nunca aberto"
and (l.get("Intencao") or "").strip().lower() in ("", "jogar", "talvez")
and ((l.get("TemConquistas") or "").strip().lower() == "sim"
or (l.get("Genero") or "").strip())
]
perolas.sort(key=lambda l: chave(l.get("Titulo") + MES))
perolas = perolas[:20]
# ---------- grava ----------
campos = [c for c in linhas[0].keys() if not c.startswith("_")]
if "Bloco" not in campos:
campos.append("Bloco")
if "CustoFechar" not in campos:
campos.append("CustoFechar")
with open(ARQ_MESTRE, "w", newline="", encoding="utf-8-sig") as fh:
w = csv.DictWriter(fh, fieldnames=campos, delimiter=";", extrasaction="ignore")
w.writeheader()
w.writerows(linhas)
try:
from openpyxl import Workbook
from openpyxl.utils import get_column_letter
except ImportError:
print("openpyxl ausente: pip install openpyxl")
print("CSV mestre gravado em", ARQ_MESTRE)
raise SystemExit
wb = Workbook()
ws = wb.active
ws.title = "Mestra"
def escrever(aba, dados, colunas):
aba.append(colunas)
for l in dados:
aba.append([l.get(c, "") for c in colunas])
for i, c in enumerate(colunas, start=1):
aba.column_dimensions[get_column_letter(i)].width = max(12, min(38, len(c) + 6))
aba.freeze_panes = "A2"
aba.auto_filter.ref = aba.dimensions
escrever(ws, acervo + cauda, campos)
colunas_fila = ["Bloco", "Titulo", "Plataforma", "Loja", "Status",
"PctConquistas", "CustoFechar", "TempoJogado"]
escrever(wb.create_sheet("Fila"), fila, colunas_fila)
colunas_perolas = ["Bloco", "Titulo", "Plataforma", "Loja", "Genero", "Intencao"]
escrever(wb.create_sheet("Perolas"), perolas, colunas_perolas)
wb.save(ARQ_XLSX)
print("acervo ......", len(acervo))
print("cauda .......", len(cauda))
print("blocos ......", ultimo, "de acervo +", ultimo + (len(cauda) - 1) // TAM_BLOCO if cauda else 0)
print("fila ........", len(fila))
print("perolas .....", len(perolas), "(" + MES + ")")
print("gravado .....", ARQ_XLSX)
Três detalhes do código que existem por um motivo específico.
O desempate (chave, loja, titulo) não é preciosismo. Como eu removo parênteses na normalização, "Batman: Arkham Asylum (GOTY)" e "Batman Arkham Asylum" geram o mesmo hash. Sem desempate, a ordem entre eles varia a cada execução e os blocos mudam sem nada mudar. Com desempate, a ordem é fixa.
E isso tem uma consequência boa para o próximo post: variantes do mesmo jogo caem no mesmo bloco, automaticamente. A normalização que eu fiz para ordenar acabou virando o detector de duplicata. O corte e a duplicata, que pareciam problemas separados, se resolvem com a mesma função.
O segundo detalhe é o l["_data"]: se o CSV não tiver data de aquisição, tudo é acervo e a cauda nasce vazia. É o comportamento certo — nenhuma data significa biblioteca toda anterior. E a partir do primeiro jogo novo que você adicionar com data, a cauda começa a funcionar sozinha.
O terceiro é que a Fila e as Pérolas não são digitadas em nenhum momento. Elas são reconstruídas a cada execução. Errou na mestra, consertou, rodou de novo. Nenhum dado derivado sobrevive à execução seguinte, e é assim que tem que ser.
O que isso muda na escrita
Uma coisa que eu não previ e que vale registrar antes de fechar.
Eu passei três posts tentando organizar a biblioteca para poder escrever sobre ela. O que o hash fez foi tirar de mim a decisão do que vem primeiro — e é uma decisão que eu estava tomando mal, porque eu ia sempre escolher os jogos que eu lembro, que são os jogos que eu gosto, que são os jogos que já tiveram espaço aqui.
Um sistema que eu controlo só me dá o que eu já sei. Um sistema que eu não controlo me dá o que eu esqueci.
E é por isso que eu escolhi o hash e não uma planilha ordenada por preferência. Não é sobre eficiência. É sobre permitir que o acervo fale primeiro.
Uma biblioteca organizada por preferência só repete o que eu já penso. Uma biblioteca organizada por acaso pode me surpreender — e é a única coisa que uma coleção de mil e seiscentos jogos tem a oferecer que quatro jogos bem escolhidos não teriam.











