Gamertag


Mostrando postagens com marcador Informática. Mostrar todas as postagens
Mostrando postagens com marcador Informática. Mostrar todas as postagens

terça-feira, 3 de novembro de 2026

A Biblioteca #3 — o hash, a fila e o problema de uma biblioteca que não para de crescer

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
Epic549Resgate semanal gratuito
GOG408Prime Gaming e resgates
Steam320Compra, na maioria
Amazon277Assinatura Prime
Windows (sem loja identificada)74A resolver pelo caminho
EA10Resgate
Uplay11Resgate
Total1.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.

sexta-feira, 30 de outubro de 2026

A Biblioteca #2 — as lojas sabem o que eu fiz, e só uma aceita contar

No post anterior, eu terminei com uma planilha feia e quatro colunas vazias. Duas delas eu preenchi sem dificuldade. As outras duas me obrigaram a admitir uma coisa incômoda: a minha biblioteca sabe o que eu tenho. Ela não sabe nada sobre o que eu fiz.

Onde o post 1 parou

Vale recapitular, porque o resto deste texto depende disso.

No primeiro post eu exportei o meu LaunchBox para um CSV. Saíram todas as linhas que ele tinha, com título, plataforma, caminho de execução, gênero, desenvolvedor. Deduzi a loja pelo caminho de instalação — Steam, Epic, GOG, Amazon — e a coluna de appid veio de brinde, porque o caminho de execução da Steam já traz o número.

O resultado foi uma planilha com a minha coleção inteira, cada linha sabendo de onde veio. A posse está resolvida. Não preciso voltar a esse assunto, e não vou.

Sobraram quatro colunas vazias: Conquistas, Progresso, Prioridade e GrupoDuplicata. E é aqui que o projeto tropeça, porque essas quatro colunas não são preenchíveis pelo mesmo caminho que eu usei até agora.

O post 1 respondeu "o que eu tenho". O post 2 precisa responder "o que eu fiz" — e são perguntas de naturezas completamente diferentes.

A distinção que destrava tudo

Existem duas perguntas numa biblioteca, e eu levei tempo para separar as duas.

A primeira é posse: o que eu tenho, em qual loja, em qual plataforma. Ela é estável, muda pouco, e o LaunchBox resolveu bem — porque foi exatamente para isso que eu o usei durante anos. Ele era o meu verificador de compra. Abria antes de aproveitar uma promoção para saber se o jogo já estava em alguma outra loja.

A segunda é uso: quanto tempo eu passei, quando foi a última vez, quantas conquistas eu tenho. Ela muda o tempo todo, e não existe nenhum lugar onde eu a tenha centralizado. Nunca existiu.

O LaunchBox tem os campos de tempo e de último acesso no XML. Estão todos vazios — e a razão é simples: eu nunca abri um jogo por ele. Eu abro pela loja. Ele registrou o catálogo, nunca o uso.

Isso não é falha do programa. É consequência do jeito que eu usei. E agora que eu sei a diferença, o problema fica bem menor do que parecia: eu não preciso redescobrir minha biblioteca. Eu preciso enriquecer a planilha que já existe com um dado que está em outro lugar.

Steam: a única que responde

Para jogo digital, quem sabe o que você fez é a loja. Ela precisa saber — é assim que ela mede engajamento, recomenda o próximo título e decide o que entra em promoção.

Só que entre as seis lojas da minha biblioteca, apenas uma devolve esse dado de forma aberta. E não é coincidência que seja a Steam.

O caminho é curto. Você pega a chave em steamcommunity.com/dev/apikey, pega o seu SteamID64, e faz uma chamada. Ela devolve a lista completa de jogos da conta, cada um com appid, nome, minutos totais jogados e timestamp do último acesso.

Tem um detalhe que trava muita gente e não aparece na maioria dos tutoriais: o seu perfil precisa estar com Game details em público. Fica em Perfil > Editar perfil > Configurações de privacidade. Se estiver privado, a API não devolve erro — devolve uma lista vazia. E você fica caçando problema no script quando o problema está na privacidade.

import csv, json, time, urllib.request, urllib.parse

API_KEY  = "SUA_CHAVE_AQUI"
STEAM_ID = "SEU_STEAMID64_AQUI"

url = "https://api.steampowered.com/IPlayerService/GetOwnedGames/v1/?" + urllib.parse.urlencode({
    "key": API_KEY,
    "steamid": STEAM_ID,
    "include_appinfo": 1,
    "include_played_free_games": 1,
    "format": "json",
})

with urllib.request.urlopen(url) as r:
    dados = json.load(r)

jogos = dados.get("response", {}).get("games", [])

if not jogos:
    print("Lista vazia. Confira: perfil publico? chave certa? SteamID64 certo?")
    raise SystemExit

with open("steam.csv", "w", newline="", encoding="utf-8-sig") as fh:
    w = csv.writer(fh, delimiter=";")
    w.writerow(["AppID", "Titulo", "MinutosTotais", "Horas", "UltimoAcesso"])

    for j in jogos:
        minutos = j.get("playtime_forever", 0)
        ultimo  = j.get("rtime_last_played", 0)
        data    = time.strftime("%Y-%m-%d", time.localtime(ultimo)) if ultimo else ""
        w.writerow([j["appid"], j.get("name", ""), minutos, round(minutos / 60, 1), data])

print("Steam: {} jogos exportados".format(len(jogos)))

Esse é o único script deste post que devolve um dado que eu nunca tive em lugar nenhum. Minutos jogados, por jogo, sem eu ter aberto nada por launcher nenhum.

E repare no que ele não faz: ele não descobre o que eu tenho. Eu já sei o que eu tenho — está no CSV do post anterior. Ele só traz o que falta.

Por que as outras cinco não respondem

Aqui eu poderia escrever cinco seções técnicas, uma por loja, e seria um texto chato e meio inútil.

O que importa é o padrão: nenhuma das outras cinco devolve histórico de uso. Não é uma questão de dificuldade minha, de ferramenta faltando ou de script mal escrito. É uma decisão de produto de cada uma delas.

A GOG guarda a biblioteca num banco local, mas o banco tem o catálogo, não o histórico. A Epic e a Amazon mantêm dados locais que descrevem o que está instalado — e instalado não é a mesma coisa que possuído, nem de longe a mesma coisa que jogado. EA e Ubisoft não mantêm nada que separe essas três coisas.

Isso não me atrapalha na posse, e é importante deixar isso claro porque era onde eu tinha me perdido antes: a posse das seis já está na planilha, vinda do LaunchBox. Eu não preciso de API nenhuma para saber que tenho o jogo. Eu preciso de API para saber o que fiz com ele — e aí, só a Steam entrega.

De seis lojas, uma me diz quanto tempo eu joguei. E ela não é a que tem a maior parte da minha biblioteca.

Juntando sem refazer

Com o CSV da Steam em mãos, a etapa final é cruzar com a planilha do post 1 — e o appid que eu já tinha extraído do caminho de execução mostra o valor dele aqui. Os jogos da Steam casam exato, sem depender de nome.

Para os que não têm appid, o casamento é por título normalizado — sem parênteses, sem marca registrada, sem pontuação, tudo em minúsculas.

import csv, re

def norm(t):
    t = (t or "").lower()
    t = re.sub(r"(?:\s*[\(\[].*?[\)\]])", " ", t)   # remove parenteses e colchetes
    t = re.sub(r"[™®©]", " ", t)
    t = re.sub(r"[^a-z0-9 ]", " ", t)
    return re.sub(r"\s+", " ", t).strip()

# 1) indice da Steam
por_appid, por_titulo = {}, {}
with open("steam.csv", encoding="utf-8-sig") as fh:
    for l in csv.DictReader(fh, delimiter=";"):
        por_appid[l["AppID"]] = l
        por_titulo[norm(l["Titulo"])] = l

# 2) a planilha do post anterior
with open("biblioteca_launchbox.csv", encoding="utf-8-sig") as fh:
    linhas = list(csv.DictReader(fh, delimiter=";"))

campos = list(linhas[0].keys())
if "Fonte" not in campos:
    campos.append("Fonte")

por_id = por_nome = sem_par = 0

for l in linhas:
    appid = (l.get("AppID") or "").strip()
    s = por_appid.get(appid) if appid else None

    if s:
        por_id += 1
    else:
        s = por_titulo.get(norm(l.get("Titulo")))
        if s:
            por_nome += 1

    if s:
        l["Loja"] = "Steam"
        l["AppID"] = l["AppID"] or s["AppID"]
        l["TempoJogado"] = s["Horas"]
        l["UltimoAcesso"] = s["UltimoAcesso"]
        l["Fonte"] = "Steam API"
    else:
        l["Fonte"] = l.get("Fonte") or ""
        sem_par += 1

with open("biblioteca_enriquecida.csv", "w", newline="", encoding="utf-8-sig") as fh:
    w = csv.DictWriter(fh, fieldnames=campos, delimiter=";", extrasaction="ignore")
    w.writeheader()
    w.writerows(linhas)

print("casados por AppID ....", por_id)
print("casados por titulo ...", por_nome)
print("sem correspondencia ..", sem_par)

Rode e você tem, pela primeira vez, uma planilha em que cada linha sabe de onde veio e, quando é Steam, quanto tempo você gastou nela.

Os "sem correspondência" não são erro. São os jogos das outras cinco lojas, mais eventuais diferenças de nome na Steam. Eles ficam com a coluna Fonte vazia, o que já é uma informação: significa "existe, mas sem histórico disponível".

Os números que aparecem

Com a coluna preenchida, três perguntas que eu não conseguia responder desde o primeiro post ficam respondíveis.

A primeira: quantos jogos da Steam eu nunca abri? Zero minuto é zero minuto. Não é estimativa, não é memória — é registro. E o número costuma ser maior do que a gente imagina.

A segunda: quais eu abri e nunca mais voltei? Último acesso de 2019, dois minutos jogados. Esses são os que a promoção vendeu e a vida não deixou jogar.

A terceira: onde estão as minhas horas de verdade? Provavelmente concentradas em cinco ou seis jogos, enquanto os outros mil e tantos dividem as migalhas. Isso muda a leitura da coleção inteira: o tamanho da biblioteca não mede nada, porque o uso é sempre concentrado.

Mil e quatrocentos jogos é um número de catálogo. Cinco jogos com trezentas horas é um retrato de quem eu sou como jogador.

A assimetria e o que ela muda na prática

Eu esperava que este post fosse sobre scripts. Ele acabou sendo sobre uma coisa mais desagradável.

Os jogos que eu tenho na Steam são os únicos que eu consigo avaliar com números. Os outros eu avalio por memória — e memória, num inventário, é uma fonte péssima. Eu já escrevi isso em outro post e continuo achando.

O efeito prático é meio injusto: uma biblioteca da Epic com duzentos jogos parece menor do que uma biblioteca da Steam com cem, porque a primeira não gera número. E o que não gera número, na prática, não existe.

Isso já está mudando uma coisa na minha forma de comprar, e é a primeira consequência real do projeto: promoção boa numa loja que não registra vale menos do que a mesma promoção numa loja que registra. Não por preferência de marca — por informação. O jogo que entra pela Steam entra na planilha com histórico. O que entra por outra loja entra como uma linha de nome.

O que vem depois

A planilha agora tem tempo, último acesso e uma coluna Fonte que diz de onde cada linha veio. Duas das quatro colunas vazias do post 1 continuam vazias — Conquistas e GrupoDuplicata.

A de conquistas é a próxima e é a mais trabalhosa, porque não vem de loja: vem do RetroAchievements para o retrô e de cada plataforma para o resto. Já sei como fazer, e o ano de RetroAchievements que eu carrego nas costas vai ajudar.

Mas a que está me incomodando agora, e que virou o assunto do post 3, é a GrupoDuplicata. Porque agora que cada linha sabe de onde veio, o que estava escondido fica visível: o mesmo jogo em duas lojas, o remaster que substitui o original, a versão com conquistas e a versão sem.

E aí eu vou ter que responder a pergunta que a planilha faz e não responde sozinha: das três versões, qual é a boa?

A biblioteca só começa a existir quando cada linha sabe de onde veio. Depois disso, ela começa a fazer perguntas que você não queria responder.

segunda-feira, 26 de outubro de 2026

A Biblioteca #1 — como eu descobri o tamanho do problema

Eu tenho mais de mil jogos. Isso não é uma conquista, é um problema administrativo que eu venho empurrando com o pé há anos. Este é o primeiro post de uma série sobre tentar resolver isso — e começa pelo passo mais chato e mais necessário: descobrir o que eu realmente tenho.

O problema que ninguém admite em voz alta

A frase "eu tenho mais de mil jogos" costuma ser dita com um certo orgulho. Ela aparece em conversa de botequim, em post de retrospectiva, em print de biblioteca da Steam com número grande em destaque. É uma frase de colecionador, e colecionador gosta de número.

Só que ela esconde uma coisa que eu demorei muito tempo para admitir: eu não sei onde estão esses mil jogos. Não sei quantos deles eu já abri. Não sei quantos eu terminei. Não sei quantos eu comprei duas vezes porque esqueci que já tinha. Não sei quantos existem em três lojas diferentes, em três versões diferentes, esperando que eu decida qual é a boa.

E o pior: eu não sei quantos deles eu realmente quero jogar.

Existe um momento específico em que esse problema deixa de ser abstrato e vira incômodo físico. É quando alguém pergunta "o que você está jogando?" e você não consegue responder sem abrir três launchers, um console, um celular e um site de tracking para conferir. É quando você senta para jogar e passa vinte minutos decidindo, e desiste, e vai fazer outra coisa. É quando você descobre que comprou o mesmo jogo de novo — não por gostar muito, mas porque não tinha como saber.

A biblioteca grande deixa de ser uma vantagem quando ela passa a exigir mais manutenção do que entrega decisão. E é exatamente aí que a maioria das pessoas faz o que eu fiz durante anos: ignora.

Uma biblioteca que você não consegue consultar não é uma biblioteca. É um depósito com interface bonita.

Por que estou escrevendo isso em série

Eu poderia escrever um post único, com um método fechado, e encerrar o assunto. Seria mais rápido e provavelmente mais preguiçoso.

O problema é que organização não funciona assim. Toda organização cria um problema novo. Você organiza por plataforma, e aí descobre que o mesmo jogo aparece três vezes. Você resolve a duplicata, e aí precisa decidir qual das três versões é a boa. Você define a boa, e descobre que a boa não tem conquistas. Você filtra por conquistas, e aí descarta trezentos jogos que você queria jogar. Você traz os trezentos de volta, e a fila fica impossível.

Cada uma dessas etapas é um post. E nenhuma delas é tutorial puro, porque nenhuma delas existe sozinha — cada problema só aparece depois que você resolve o anterior.

Por isso a série se chama A Biblioteca. Não é um guia. É o registro de uma tentativa que segue em andamento, com a biblioteca crescendo enquanto eu escrevo.

O que o LaunchBox já sabe e eu não sabia que ele sabia

Existe uma coisa boa nessa história toda, e ela me economizou semanas de trabalho.

Eu uso o LaunchBox há anos. Ele está lá ligado às lojas, catalogando jogos, puxando capa, sinopse, data de lançamento, gênero. Eu uso como launcher: abro, escolho, jogo. Nunca pensei nele como banco de dados.

E é exatamente isso que ele é. O LaunchBox guarda a biblioteca inteira em arquivos XML, um por plataforma, dentro da pasta Data\Platforms da instalação. Cada jogo vira um bloco com título, plataforma, caminho de execução, gênero, desenvolvedor, data de lançamento, número de vezes que foi aberto, tempo jogado, último acesso, status, se está completado, se é favorito.

Ou seja: a parte mais chata do inventário — a coleta — já está feita. Eu passei anos com o banco de dados pronto e nunca abri.

E tem um detalhe que parece pequeno e resolve metade do trabalho: o campo do caminho de execução revela a loja sem nenhum preenchimento manual. Se o caminho começa com steam://rungameid/, o jogo é da Steam — e o número que vem depois é o appid, que é a chave que abre a API da Steam depois. Se aparece epicgames, é Epic. Se aparece gog, é GOG. Ou seja: a coluna de loja não precisa ser preenchida à mão, ela pode ser deduzida.

Isso importa porque a diferença entre um inventário que existe e um inventário que não existe é quase sempre o mesmo detalhe: quanto trabalho manual ele exige. Inventário que dá trabalho não é atualizado. Inventário que não é atualizado vira ficção em três meses.

O que ele não sabe

Preciso ser honesto sobre o limite, porque descobri da forma errada.

O LaunchBox sabe o que você tem. Ele não sabe o que você fez.

Ele não traz conquistas de Steam, PSN, Xbox, Epic, GOG ou RetroAchievements. Ele tem um campo de tempo jogado, mas esse campo só é confiável para jogos que foram abertos pelo próprio LaunchBox — se você jogou direto pela Steam, ele não sabe.

Então a divisão fica assim, e ela organiza toda a série: o LaunchBox é a espinha da posse. O progresso vem de fora, de cada serviço, e vai ser assunto de outro post. O que eu preciso agora é só a base — o que existe, onde está, quantas vezes foi aberto.

Duas formas de chegar ao CSV

Existem dois caminhos, e a escolha entre eles não é sobre dificuldade. É sobre repetição.

O caminho sem programação é mais rápido no primeiro dia. O caminho com Python é mais rápido no segundo, no terceiro, no décimo — porque vira um duplo clique. E como a biblioteca cresce, o segundo caminho é o único que sobrevive. Vou mostrar os dois e você decide.

Caminho 1 — sem instalar nada: Excel lendo os XMLs

O Excel lê XML nativamente. Não precisa de plugin, não precisa de programação, não precisa de nada além do Office que você provavelmente já tem.

O processo é este:

  1. Feche o LaunchBox. Isso não é opcional — ele reescreve os XMLs ao sair, e ler no meio da escrita pode truncar o arquivo.
  2. Abra o Excel e vá em Dados > Obter Dados > De Arquivo > Do XML
  3. Navegue até a pasta Data\Platforms da instalação do LaunchBox
  4. Escolha o XML de uma plataforma — por exemplo, o da Steam
  5. Na janela do navegador que abre, selecione a tabela Game e clique em Carregar
  6. O Excel monta uma planilha com uma linha por jogo e uma coluna por campo
  7. Salve como CSV, ou repita o processo numa aba por plataforma e junte depois

Funciona. É o caminho que eu recomendaria para quem quer só ver os números uma vez e não pretende mexer nisso de novo.

Mas ele tem três defeitos que aparecem rápido. O primeiro: você precisa repetir por plataforma, uma por uma — e se você tem vinte plataformas catalogadas, são vinte importações. O segundo: os campos que aparecem mais de uma vez no XML, como gênero e modo de jogo, viram tabelas aninhadas, e o Excel pode expandir isso em linhas extras que quebram a contagem. O terceiro, e o mais importante: ele não é repetível. Semana que vem, quando você adicionar trinta jogos, você refaz tudo do zero.

Caminho 2 — com Python: instalação no Windows, do zero

Se você nunca usou Python no Windows, essa parte costuma ser o ponto onde o tutorial perde a pessoa. Vou detalhar como se você nunca tivesse aberto um terminal.

Passo 1 — verificar se já está instalado.

Abra o menu Iniciar, digite PowerShell e abra. Na janela azul, digite:

python --version

Se aparecer algo como Python 3.12.4, você já tem e pode pular para o passo 4. Se aparecer uma mensagem dizendo que o termo não é reconhecido, siga para o passo 2.

Passo 2 — instalar.

Com o PowerShell aberto, rode:

winget install Python.Python.3.12

Ele baixa e instala sozinho. Aceite os termos se aparecer pedido. Se o winget não existir na sua máquina, baixe o instalador em python.org e — este detalhe é o que mais gente esquece — marque a caixa "Add python.exe to PATH" na primeira tela do instalador. Sem essa caixa, o comando python nunca funciona depois.

Passo 3 — confirmar.

Feche o PowerShell e abra de novo, porque o Windows só recarrega as variáveis de ambiente em janelas novas. Digite outra vez:

python --version

Agora deve responder com a versão. Se ainda reclamar, reinicie o computador — resolve em quase todos os casos.

Passo 4 — criar o arquivo do script.

Crie uma pasta onde você quiser guardar isso. Sugestão: C:\Biblioteca.

Abra o Bloco de Notas, cole o script que está mais abaixo, e salve nessa pasta com o nome exportar.py. Duas armadilhas clássicas do Bloco de Notas: no campo "Tipo", escolha Todos os arquivos (*.*), senão ele salva como exportar.py.txt e nada funciona. E na codificação, escolha UTF-8, senão os acentos dos títulos chegam quebrados no Excel.

Se você tiver o VS Code ou o Notepad++ instalado, use um deles — lidam melhor com codificação e com a extensão.

O script

Este é o script completo. Ele varre todos os XMLs de plataforma, extrai os campos, deduz a loja pelo caminho de execução, e grava um CSV com separador de ponto e vírgula — que é o que o Excel em português espera por padrão.

import csv, glob, os, re
import xml.etree.ElementTree as ET

# 1) Caminho do LaunchBox. Ajuste se o seu estiver em outro lugar.
LB = r"C:\LaunchBox"

def loja_e_appid(path):
    if not path:
        return "", ""
    m = re.search(r"steam://rungameid/(\d+)", path)
    if m:
        return "Steam", m.group(1)
    if "epicgames" in path:
        return "Epic", ""
    if "gog" in path.lower():
        return "GOG", ""
    return "Local", ""

pasta_xml = os.path.join(LB, "Data", "Platforms")
arquivos = glob.glob(os.path.join(pasta_xml, "*.xml"))

if not arquivos:
    print("Nenhum XML encontrado em: " + pasta_xml)
    print("Confira o caminho do LaunchBox na primeira linha do script.")
    raise SystemExit

rows = []

for xml_path in arquivos:
    plataforma_arquivo = os.path.splitext(os.path.basename(xml_path))[0]

    try:
        root = ET.parse(xml_path).getroot()
    except ET.ParseError:
        print("Aviso: nao consegui ler " + plataforma_arquivo + ".xml. Pulando.")
        continue

    for g in root.findall("Game"):
        def campo(tag):
            el = g.find(tag)
            return (el.text or "").strip() if el is not None else ""

        titulo = campo("Title")
        if not titulo:
            continue

        loja, appid = loja_e_appid(campo("ApplicationPath"))

        rows.append({
            "Titulo": titulo,
            "Plataforma": campo("Platform") or plataforma_arquivo,
            "Loja": loja,
            "AppID": appid,
            "Caminho": campo("ApplicationPath"),
            "Genero": campo("Genre"),
            "Desenvolvedor": campo("Developer"),
            "DataLancamento": campo("ReleaseDate"),
            "VezesJogado": campo("PlayCount"),
            "TempoJogado": campo("PlayTime"),
            "UltimoAcesso": campo("LastPlayed"),
            "Status": campo("Status"),
            "Completado": campo("Completed"),
            "Favorito": campo("Favorite"),
            "GrupoDuplicata": "",
            "Conquistas": "",
            "Progresso": "",
            "Prioridade": "",
        })

if not rows:
    print("Os XMLs foram lidos, mas nenhum jogo foi encontrado dentro deles.")
    raise SystemExit

saida = os.path.join(os.path.dirname(os.path.abspath(__file__)), "biblioteca_launchbox.csv")

with open(saida, "w", newline="", encoding="utf-8-sig") as fh:
    w = csv.DictWriter(fh, fieldnames=list(rows[0].keys()), delimiter=";")
    w.writeheader()
    w.writerows(rows)

print("Pronto: " + str(len(rows)) + " jogos exportados.")
print("Arquivo gerado em: " + saida)

Três coisas para você entender o que está acontecendo, porque script que a gente não entende é script que a gente não conserta:

A primeira linha define onde está o LaunchBox. Se o seu estiver em outro caminho, mude ali — e mantenha o r antes das aspas, que é o que faz o Windows aceitar as barras invertidas sem reclamar.

O bloco loja_e_appid é a parte que economiza trabalho manual. Ele procura o padrão da Steam dentro do caminho de execução e, quando encontra, separa a loja e guarda o appid numa coluna própria. Esse appid é o que vai permitir puxar horas e conquistas depois, sem precisar cruzar nome por nome.

As quatro últimas colunas — grupo de duplicata, conquistas, progresso e prioridade — são criadas vazias de propósito. Elas são o espaço reservado para as próximas etapas. A de grupo de duplicata é a mais importante de todas, e explico por quê mais adiante.

Como rodar

Passo 1 — feche o LaunchBox. Repetindo porque é a causa mais comum de erro: o LaunchBox reescreve os XMLs ao encerrar.

Passo 2 — abra o terminal na pasta certa. Abra a pasta C:\Biblioteca no Explorador de Arquivos, clique num espaço vazio segurando Shift e escolha "Abrir janela do PowerShell aqui" no Windows 10, ou "Abrir no Terminal" no Windows 11. No Windows 11 também funciona digitar powershell direto na barra de endereço da pasta.

Passo 3 — rode.

python exportar.py

Se tudo der certo, você vê uma mensagem com o número de jogos exportados e o caminho do CSV. O arquivo aparece na mesma pasta do script.

Passo 4 — abra no Excel. Duplo clique no CSV. Se o Excel abrir tudo numa coluna só, é problema de separador: vá em Dados > Texto para Colunas e escolha Delimitado > Ponto e vírgula. Isso resolve.

Quando dá errado

O que aparece O que significa O que fazer
'python' não é reconhecido Python não está no PATH Reinstalar marcando "Add python.exe to PATH", ou reiniciar o PC
Nenhum XML encontrado O caminho do LaunchBox está errado Conferir a primeira linha do script
Aviso: nao consegui ler... XML truncado pela gravação do LaunchBox Fechar o LaunchBox e rodar de novo
UnicodeDecodeError Arquivo salvo com codificação errada Salvar o .py como UTF-8
CSV abre tudo numa coluna Separador não reconhecido Texto para Colunas > Ponto e vírgula
Acentos quebrados no Excel Codificação da leitura O script já grava em UTF-8 com BOM; se persistir, importar via Dados > De Texto/CSV

A coluna que vai salvar o projeto

Antes de fechar, preciso falar da coluna vazia que parece menos importante e é a mais decisiva: GrupoDuplicata.

Ela existe porque o seu número total de jogos é ficção até você decidir o que conta como um jogo. Se você tem Cities: Skylines na Steam, na Epic e no Switch, isso é um jogo ou três? Para efeito de contagem, um. Para efeito de posse, três. E o mesmo vale para remaster, para relançamento, para a versão de Wii de um jogo que você também tem no Switch.

Sem essa coluna, você vai olhar para mil e quatrocentas linhas e não vai saber que quatrocentas delas são duzentos jogos. Com ela, o número real aparece — e o número real é sempre menor, e é sempre mais honesto, e é sempre mais útil.

O preenchimento dela é manual e é a próxima etapa da série. Mas a coluna precisa existir desde agora, porque planilha sem espaço reservado não recebe dado depois.

O inventário não serve para saber quantos jogos você tem. Serve para descobrir quantos deles existem de verdade.

O que vem depois

Com o CSV em mãos, o próximo passo é enriquecer: puxar horas e conquistas da Steam e do RetroAchievements, que são os dois maiores blocos e os dois que têm API aberta. Depois vem PSN, Xbox e Google Play via Exophase. Depois a varredura dos físicos que ficaram fora do LaunchBox — e essa é a parte que vai levar semanas, porque nenhum software sabe o que está na sua estante.

É aí que os números começam a dizer alguma coisa. E o que eles costumam dizer é desconfortável: uma parte grande da biblioteca nunca foi aberta.

Mas esse é o post da semana que vem.

Por enquanto, o que existe é uma planilha feia, com quatro colunas vazias, que representa a primeira vez em anos que eu consegui olhar para a minha biblioteca inteira e ver o que está lá.

O primeiro passo de organizar mil jogos não é organizar nenhum deles. É admitir que você não sabe o que tem.

quinta-feira, 27 de março de 2025

Como inserir auto filtro no Calc do LibreOffice?

Como usar Auto Filtro no LibreOffice Calc

Como usar Auto Filtro no LibreOffice Calc

Trabalhar com grandes volumes de dados pode ser caótico se você não tiver boas ferramentas de organização. Uma das mais simples e úteis no LibreOffice Calc é o Auto Filtro.

Ele permite adicionar setas nos títulos das colunas da planilha para que você possa filtrar os dados rapidamente, sem alterar o conteúdo original.

📌 Como aplicar o Auto Filtro:

  1. Abra a sua planilha no LibreOffice Calc.
  2. Certifique-se de que sua primeira linha é o cabeçalho (com os nomes das colunas).
  3. Selecione a linha do cabeçalho ou toda a tabela de dados.
  4. No menu superior, clique em Dados → Filtro → AutoFiltro.
  5. Setas aparecerão nos títulos das colunas — clique nelas para filtrar!

🔍 O que dá para fazer com o filtro:

  • Filtrar por um valor específico (ex: mostrar só quem está com “Status: Ativo”).
  • Ordenar em ordem crescente ou decrescente.
  • Ocultar temporariamente dados que não são relevantes.

💡 Dica extra:

Se você trabalha com relatórios ou tabelas dinâmicas, o Auto Filtro pode ser seu melhor amigo para análises rápidas. Combine com formatação condicional para destacar dados importantes visualmente.


“Organizar é o primeiro passo para enxergar o que realmente importa.”

quarta-feira, 26 de março de 2025

Criando Links para Partes do Próprio Texto no Writer

Como criar links internos no LibreOffice Writer

Como criar links para partes do próprio texto no LibreOffice Writer

Se você está escrevendo um texto longo no LibreOffice Writer, como um TCC, manual, ebook ou documento técnico, pode ser muito útil criar links internos — que levam o leitor de uma parte do texto diretamente para outra.

Com isso, você facilita a navegação e melhora a organização do conteúdo.

🔗 Como fazer isso:

  1. Primeiro, marque a parte do texto para onde deseja criar o link:
    • Selecione o título ou trecho de destino.
    • No menu, vá em Inserir → Marcador.
    • Dê um nome (ex: capitulo1) e clique em OK.
  2. Agora, crie o link que levará até esse marcador:
    • Selecione o texto que será clicável (por exemplo, “Ir para o Capítulo 1”).
    • Clique com o botão direito e vá em Inserir → Hiperlink.
    • Escolha a opção Documento no menu lateral.
    • Clique no botão de alvo (ícone de pasta com uma seta).
    • Na janela que abrir, selecione o marcador criado (ex: capitulo1).
    • Clique em Aplicar ou OK.

📌 Quando usar?

  • Índices clicáveis
  • Referências cruzadas em documentos técnicos
  • Navegação entre capítulos
  • Documentos interativos para PDF

💡 Dica extra

Se você exportar o documento como PDF, os links internos continuam funcionando — ou seja, você terá um arquivo navegável como se fosse um site.


“A melhor estrutura de texto é aquela que guia sem forçar e leva sem confundir.”

terça-feira, 25 de março de 2025

Como formatar um link no LibreOffice Writer?

Como formatar um link no LibreOffice Writer

Como formatar um link no LibreOffice Writer

Inserir e personalizar um link no LibreOffice Writer é simples, mas muitas pessoas não sabem que dá para mudar cor, sublinhado, estilo e até remover o link mantendo o texto.

📌 Inserindo um link

  1. Selecione o texto que você deseja transformar em link.
  2. Clique com o botão direito e escolha Inserir → Hiperlink.
  3. No campo de destino, digite a URL desejada (ex: https://exemplo.com).
  4. Clique em Aplicar ou OK.

🎨 Formatando o link

Por padrão, o Writer aplica um estilo azul sublinhado. Mas você pode mudar isso:

  1. Vá em Estilos → Estilos de Caractere (F11).
  2. Procure o estilo chamado Internet Link ou Visited Internet Link.
  3. Clique com o botão direito sobre o estilo e escolha Modificar.
  4. Na aba Fonte ou Efeitos de Fonte, altere a cor, sublinhado, tipo da fonte, etc.
  5. Confirme e veja os links atualizarem automaticamente com o novo visual.

🧽 Removendo o link (mantendo o texto)

Se quiser manter o texto mas remover o hiperlink:

  • Clique com o botão direito no link.
  • Escolha Remover Hiperlink.

💡 Dica final

Você pode criar estilos personalizados para links internos, e-mail ou navegação entre seções do próprio documento. O Writer reconhece links automaticamente quando você digita uma URL completa, então vale revisar o estilo para manter a estética do seu texto.


“A forma como guiamos o leitor diz tanto quanto o destino do link.”

segunda-feira, 24 de março de 2025

Como escrever sem limitador de página no LibreOffice Writer

Como escrever sem limitador de página no LibreOffice Writer

Como escrever sem limitador de página no LibreOffice Writer

Se você usa o LibreOffice Writer para escrever textos longos, como rascunhos de livros, roteiros ou até mesmo posts para blog, talvez já tenha se incomodado com os limites de página. Aquela quebra visual constante pode atrapalhar o fluxo criativo.

Felizmente, há uma maneira simples de remover esse limitador e escrever em um único espaço contínuo, como em um editor de texto puro.

✨ Como fazer isso:

  1. Abra o documento no LibreOffice Writer.
  2. No menu superior, clique em Exibir (ou View).
  3. Desmarque a opção Limites de Página (ou Page Breaks).
  4. Pronto! O documento agora será exibido sem a divisão de páginas visível.

💡 Dica extra:

Se você quiser uma visualização ainda mais fluida, vá em Formatar → Página → Página e altere o tamanho do papel para algo personalizado, com margens reduzidas. Isso deixa a tela mais “livre”.

🧠 Por que usar essa opção?

Remover o limitador de página ajuda a manter o foco no conteúdo, especialmente se a divisão de páginas não for relevante para o que está escrevendo. É ideal para quem quer se concentrar nas ideias, não na formatação.


“Escrever sem páginas é como sonhar sem fim — você só precisa deixar as palavras fluírem.”

terça-feira, 11 de março de 2025

Como trocar a thumbnail de um vídeo usando FFmpeg no Windows

Como trocar a thumbnail de um vídeo usando FFmpeg no Windows

Como trocar a thumbnail de um vídeo usando FFmpeg no Windows

23/03/2025

“Uma boa capa pode não mudar o conteúdo... mas muda completamente a primeira impressão.”
Trocar thumbnail com FFmpeg

🛠️ O que você vai precisar:

  • O vídeo original (.mp4 ou .mkv)
  • Uma imagem no formato .jpg (de preferência 1280x720)
  • O programa FFmpeg instalado e configurado no PATH do sistema

📥 Passo 1 – Baixe e instale o FFmpeg

Você pode baixar o FFmpeg pelo site oficial: ffmpeg.org/download.html. Após isso, adicione a pasta bin ao PATH do sistema para conseguir rodar o comando direto no terminal.

🖼️ Passo 2 – Prepare sua imagem

Escolha a imagem que você deseja como thumbnail e salve como thumbnail.jpg. Ela será embutida no arquivo de vídeo como capa.

📁 Passo 3 – Coloque tudo em uma mesma pasta

Coloque o vídeo original e a imagem thumbnail.jpg na mesma pasta para facilitar a execução do comando.

📜 Passo 4 – Use o comando mágico

Abra o terminal (Prompt de Comando) na pasta onde estão os arquivos e execute:

ffmpeg -i seuvideo.mp4 -i thumbnail.jpg -map 0 -map 1 -c copy -disposition:1 attached_pic saida.mp4

Esse comando cria um novo arquivo saida.mp4 com a thumbnail embutida.

🔄 Passo 5 – Teste e limpe o cache de miniaturas

Abra o vídeo com um player como VLC para ver a thumbnail funcionando. Caso o Windows Explorer não atualize a miniatura automaticamente, limpe o cache de miniaturas com o utilitário de limpeza de disco.

✅ Resultado

Agora seu vídeo terá uma miniatura personalizada visível no Explorer, players compatíveis e ferramentas de organização de mídia!