Compare commits

...
4 Commits
Author SHA1 Message Date
MateuusandClaude Opus 5.5 ed31d52df0 IA: Claude, Codex e Gemini com login, chave de API e IA reserva; Configurações em subpáginas
- Configurações → IA (/settings/ai): um cartão por IA para instalar/atualizar a CLI pelo painel, ligar,
  entrar com a conta (OAuth pela própria CLI, num terminal) ou colar a chave de API, e testar.
  Chaves cifradas com a DPAPI do Windows em data/ai/vault.bin; só vão para a CLI no ambiente da chamada.
- Gemini CLI como terceiro agente do painel (stream-json, edição automática, shell só o liberado).
- IA reserva: execução que cai por indisponibilidade (cota, 429, login, chave, rede) pausa a IA e recomeça
  a mesma tarefa na próxima pronta da ordem; migração v10 (agent_runs.fallback_of).
- Configurações viraram subpáginas (IA, Publicação, Apps das redes, Navegador, Sobre os modos), também no
  menu lateral; links antigos apontam para a subpágina certa.
- Contrato com o Clipador em doc/ia.md; skill do CenaForge atualizada até a 1.51.0.

O login gratuito do Gemini CLI para conta pessoal foi encerrado pelo Google (IneligibleTierError): para
conta pessoal, use a chave do AI Studio.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 01:51:12 -03:00
MateuusandClaude Opus 5.5 0567c7454a Clipador: subpáginas, jogos, idioma por canal e juiz com Gemini e IA reserva
- Clipador em subpáginas (Cortes, Sessões, Fontes, Jogos, Ajustes) com moldura comum, lista + diálogo
  dos cortes e submenu na barra lateral.
- Perfis de jogo (o que a IA sabe de cada jogo), parar pausa o monitor e idioma por fonte e por canal
  de publicação (migração v9: accounts.language).
- Juiz: Gemini CLI como terceiro provedor e IA reserva por chamada — se a IA escolhida cair por cota,
  login, chave ou rede, a próxima da ordem de Configurações → IA responde (com pausa da que caiu).
  Lê data/ai/settings.json e o cofre data/ai/vault.bin (DPAPI) escritos pelo painel; contrato em doc/ia.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 01:51:12 -03:00
MateuusandClaude Opus 5.5 2d8b1a582d Cartoon: mãos, membros e cenários novos; elenco de Noé e a Arca
- Mãos com formas e rotações próprias, membros articulados (limbs) e animais.
- Elementos de cenário separados (natureza, construções, interiores) e testes de lugares.
- Personagens reaproveitáveis de Noé e a Arca (Noé, esposa, Sem, Cam e Jafé) e a fonte Barlow Semi Condensed.
- História noe-e-a-arca: pauta, bíblia, roteiro do ep. 1, tomadas Cartoon e montagem.
- Montagem: narração mais corrida (tira silêncios longos) e cabeçalho com o número do vídeo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 01:51:11 -03:00
MateuusandClaude Opus 5.5 3f600c55b1 Cartoon: rig, movimento e lip sync dos personagens
- cartoon/src/rig.ts, motion.ts e lipsync.ts: esqueleto do personagem,
  curvas de movimento e sincronia labial no estilo Cartoon (Remotion)
- CharacterFigure/CharacterCard/Shot/overlays e spec atualizados
- Painel: estúdio de personagens e montagem cartoon ajustados
- Documentação em doc/cartoon/animacao.md e personagens.md; skill atualizada

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 23:39:12 -03:00
163 changed files with 29191 additions and 3146 deletions
+72
View File
@@ -7,6 +7,78 @@ Versão semântica da **skill** (não do projeto):
Mantido pelo subagente `cenaforge-skill-updater`. Entradas mais novas no topo. Mantido pelo subagente `cenaforge-skill-updater`. Entradas mais novas no topo.
## 1.51.0 — 18/11/2026
IA: três provedores (Claude Code, Codex, Gemini CLI), login ou chave de API no cofre e IA reserva.
- `references/ai.md` (novo): onde mexer (`panel/src/lib/ai.ts`, `agents.ts`, `app/api/ai/`, `ai-settings.tsx`,
`clipper/app/ai_settings.py`, `judge.py`), regras (só o painel escreve `data/ai/`, chave só no ambiente da chamada,
quando a reserva troca), estado verificado. Contrato completo em `doc/ia.md`.
- `references/panel.md`: banco v10 (`agent_runs.fallback_of`); "Agentes e modelos" com 3 provedores, reserva e
Configurações em subpáginas (`SETTINGS_SECTIONS`).
- `references/clipper.md`: juiz com `gemini` e reserva por chamada; chave só pelo cofre do painel.
- `references/gotchas.md`: seção "IA" com 168–172 (OAuth do Gemini encerrado, `CODEX_API_KEY`, terminal de login no
Windows, custo da DPAPI, CLI fora do PATH). O 167 já era do perfil de jogo (1.50.0); numeração ajustada.
- `references/tools.md`: Gemini CLI como candidata (não instalada aqui, nunca executada); `--version` de Claude e Codex.
- `SKILL.md`: versão, `description`, esquema v10, linha "IA" em "Onde mexer", invariante da chave de API.
- Evidência (reexecutada): `claude` 2.1.314, `codex-cli` 0.169.0, `gemini` ausente; `ai.test.ts` 21/21; `pnpm test:clipper`
335 passed. Informado, não reexecutado: painel 104/104, ida e volta do cofre. Não verificado: Gemini com chave, `@arquivo`
de imagem no juiz, envelope de erro do `-o json`, UI no navegador.
## 1.50.0 — 18/11/2026
Clipador: perfis de jogo bilíngues, missões e gatilhos de fim, cadastro de jogo pelo painel, semente do GTA VI.
- `references/clipper.md`: banco em v12; seção "Perfil do jogo" reescrita (`profile` pt × `profileAi` en, aliases,
`missions`, `end_triggers`, rotas novas `POST/DELETE /v1/games`, `translate`, `PUT ?lang=`, seções novas do refine,
sementes, proxy/timeouts); linhas de "Onde mexer" e de páginas; evidência.
- `references/panel.md`: `/clipper/games` em lista + modal (`clipper-game-dialog.tsx`, `clipper-game-parts.tsx`);
ícones dos subitens da sidebar.
- `references/gotchas.md`: novo 167 (serviço sem reiniciar, `profileAi: null`, alias, missões não oficiais do GTA VI).
- `SKILL.md`: versão, `description` (perfil bilíngue, missões, cadastro de jogo) e faixa de itens do Clipador.
- Evidência: conferido em `clipper/app/main.py`, `db.py` (v12), `judge.py` (`mission_lines`), `intel.py`,
`panel/src/lib/clipper.ts` e `doc/clipador/JOGOS.md`; `pnpm test:clipper` → 335 passed (reexecutado). Não verificado:
IA real, UI no navegador, banco real em v12, `pnpm typecheck`.
## 1.49.0 — 18/11/2026
Clipador: interface em subpáginas, parar à mão pausa o monitor, idioma por fonte/sessão/canal.
- `references/clipper.md`: banco em v11; linha "Páginas `/clipper/*`" reescrita (grupo `(studio)`, provider, shell, páginas);
linha nova de pausa do monitor e idioma em "Onde mexer"; seção "Parar é parar e idioma"; evidência.
- `references/panel.md`: seção `/clipper` reescrita (tabela rota, conteúdo, arquivos; `clipper-studio.tsx` apagado,
`clipper-queue.tsx` e `clipper-sessions.tsx` reduzidos); esquema do painel v9 (`accounts.language`, `languages.ts`).
- `references/gotchas.md`: novo 166 (fonte que não volta a gravar depois de parar à mão; rotas novas exigem reiniciar o Clipador).
- `SKILL.md`: versão, `description`, linhas de página e de armadilhas.
- Evidência: conferido em `doc/clipador/REDESIGN.md`, `clipper-shell.tsx` (`CLIPPER_SECTIONS`), `clipper/app/db.py` (v11),
`main.py` (`StopIn`, `check_language`), `panel/src/lib/db.ts` (v9) e `languages.ts`; `pnpm test:clipper` → 287 passed
(reexecutado). Não verificado: páginas no navegador, banco real em v11, `pnpm typecheck` e testes do painel.
## 1.48.0 — 17/11/2026
Cartoon: acabamento de ilustração dos personagens (detalhe de rosto/corpo, acessórios, enquadramento e textura).
- `references/cartoon.md`: campos opcionais do `look` (`head`, `nose`, `lids`, `wrinkles`, `belly`, `accessories`,
`accessoryColor`); `lid` em `FaceParams`; `framing` do ator e `grain` do spec; acabamento do `CharacterFigure`;
`describeToLook` com regras de detalhe e profissões novas; `planCartoon` escolhe `framing`; campos novos no studio; medição.
- `references/gotchas.md`: novos 163 (curva da boca — registrado de fato só agora; o 1.47.0 o citava sem ele existir no
arquivo), 164 (Python grava JSON sem `encoding="utf-8"` estraga acento), 165 (sombra em elipse parece mancha).
- `SKILL.md`: versão, `description`, linha do personagem, faixa de itens do Cartoon (156, 157, 160–165). Sem crescer.
- Evidência: conferido em `character.ts`, `rig.ts`, `spec.ts`, `Shot.tsx`, `overlays.tsx`, `characters.ts`,
`montage-cartoon.ts`; `cd cartoon && npx tsx --test tests/*.test.ts` → 16 pass (reexecutado). Informados, não
reexecutados: painel 78/78, `tsc`, 4 personagens por descrição, close falando renderizado.
## 1.47.0 — 17/11/2026
Cartoon: rig de expressões, ações de movimento combináveis e fala sincronizada (ferramenta, não template).
- `references/cartoon.md`: nova seção "Rig, movimento e fala" (`rig.ts`: `FaceParams`/`BodyParams`, 20 expressões e 17 poses
como atalhos; `motion.ts`: `Action`, 19 ações, `evaluate`, `startOf`/`cue`, `validateTimeline`; `lipsync.ts`: `visemeAt`,
`emphasisAt`, `speak`); contrato do ator com `face`/`body`/`timeline` e `spec.audioEnv`; `timelineFor`/`audioEnvelope` no
plano do painel; exports `./motion` e `./rig`; prévia de movimento no `character-studio`; medições.
- `references/gotchas.md`: novo 163 (curva quadrática da boca só chega à metade do controle).
- `references/tools.md`: contagem de testes (cartoon 16, painel 10 no arquivo do Cartoon).
- `SKILL.md`: versão, `description`, linha de personagem com rig/movimento e `animacao.md`; resumo de armadilhas enxugado
(a lista longa de itens saiu: vale o `gotchas.md`).
- Evidência: conferido no código (`package.json` exports, `rig.ts`, `motion.ts`, `lipsync.ts`, `montage-cartoon.ts`);
`cd cartoon && npx tsx --test tests/*.test.ts` → 16 pass (reexecutado). Informados, não reexecutados: painel 78/78, `tsc`,
grade das 20 expressões, narração real da ilha ep01-01 e sequência de 7 s renderizada em 5,6 s.
## 1.46.0 — 17/11/2026 ## 1.46.0 — 17/11/2026
Cartoon por peças: lugares montados pelo texto e biblioteca de personagens reaproveitados entre histórias. Cartoon por peças: lugares montados pelo texto e biblioteca de personagens reaproveitados entre histórias.
File diff suppressed because one or more lines are too long
+44
View File
@@ -0,0 +1,44 @@
# IA: três provedores, login/chave e IA reserva
Fonte do contrato: **`doc/ia.md`** (arquivos, ambiente de cada chamada, o que conta como indisponível, Gemini
headless). Não duplique aqui; este arquivo diz onde mexer e o que não quebrar. Sempre pela **CLI oficial**
(`claude`, `codex`, `gemini`), nunca SDK/HTTP direto.
## Onde mexer
| Mudança | Arquivo(s) | Também atualizar |
|---|---|---|
| Configurações, cofre, detecção, instalação, login, teste, `providerEnv`, `isAvailabilityError`, pausa, `readyChain`/`nextFallback` | `panel/src/lib/ai.ts` | `panel/src/lib/ai.test.ts`, `doc/ia.md` |
| Agente do painel por provedor (`geminiArgs`, `normalizeGemini`, `--resume`, shell liberado), troca de IA ao cair | `panel/src/lib/agents.ts` (`prompts.ts`, `types.ts` para `AgentProvider`) | `ai.test.ts` (argumentos e eventos do Gemini) |
| Execução que continua outra que caiu | coluna `agent_runs.fallback_of` (migração v10 em `panel/src/lib/db.ts`), `followUpRunOf` (segue `resume_of` **e** `fallback_of`) | `publishing-db.test.ts` (conta de migrações) |
| API | `panel/src/app/api/ai/route.ts` (`GET/PUT /api/ai`), `.../ai/[provider]/route.ts` (`POST {action: install\|login\|verify\|test\|resume}`, `PUT/DELETE` = chave) | guarda `Origin`/JSON (gotchas, item 125) |
| Tela | `panel/src/components/ai-settings.tsx` em `panel/src/app/settings/ai/page.tsx`; seletor de provedor em `agent-console.tsx` e `story-composer.tsx` | — |
| Subpáginas de Configurações | `panel/src/app/settings/{ai,publishing,apps,browser,modes}/page.tsx` + `layout.tsx`; seções em `SETTINGS_SECTIONS` de `components/settings-shell.tsx` (o menu lateral `sidebar-nav.tsx` as lê como `children`); `/settings` redireciona para `/settings/ai` | seção nova = entrada em `SETTINGS_SECTIONS` + pasta |
| Juiz do Clipador (3 provedores, reserva por chamada) | `clipper/app/judge.py` (`_gemini`, `find_gemini`, `parse_gemini_output`), leitura de settings e cofre `clipper/app/ai_settings.py` (DPAPI por `ctypes`), `main.py`, `config.py`, `intel.py` | `clipper/tests/test_ai_fallback.py`, `conftest.py`, `clipper/README.md` |
## Regras
- **Só o painel escreve** `data/ai/settings.json` e `data/ai/vault.bin`; o Clipador só lê (relê por `mtime`). Cofre =
DPAPI `CurrentUser`, entropia `CenaForge.AI.vault.v1`; a chave nunca volta à tela (só "existe" + 4 últimos
caracteres). Nunca copie chave para skill, log ou prompt.
- Chave de API entra **só no ambiente da chamada** (`providerEnv`); não troque o login global da CLI.
- **Reserva:** erro de indisponibilidade (cota, 429, login, chave, rede, CLI fora, tempo) → a IA entra em pausa
(`cooldownMin`, em memória por processo) e a **mesma tarefa recomeça** na próxima IA pronta de `order`. Erro de
conteúdo (JSON/schema inválido) **não** troca. O juiz faz o mesmo por chamada.
- Gemini no agente: `-o stream-json --approval-mode auto_edit --skip-trust`, `--resume <sessão>`, shell só os comandos de
`GEMINI_ALLOWED_SHELL` via `--allowed-tools run_shell_command(...)`. No juiz: `-o json --approval-mode plan`, prompt
pelo stdin, frames copiados para pasta temporária **fora do repo** (`@arquivo` respeita o `.gitignore`).
- Status de login: `claude auth status --json` (`loggedIn`, `authMethod`, `subscriptionType`); `codex login status`
(texto, "Logged in using ChatGPT").
- Instalação: Claude pelo instalador nativo (`irm https://claude.ai/install.ps1 | iex`); Codex e Gemini por
`npm install -g`. O painel procura também em `~/.local/bin` e `%APPDATA%\npm`.
## Estado verificado (18/11/2026)
- Nesta máquina: `claude` 2.1.314 e `codex` 0.169.0 (`--version` reconferido pela skill); `gemini` **não instalado**
(`command not found`).
- `pnpm --filter cenaforge-panel test:panel` inclui `ai.test.ts`: 21 testes, 21 passaram (reexecutado pela skill; um
usa a DPAPI real). Clipador: `pnpm test:clipper` → 335 passed (reexecutado). Suíte do painel 104/104: informada.
Ida e volta real do cofre painel → Clipador: informada, não repetida.
- **Não verificado:** Gemini com chave real, `@arquivo` de imagem no juiz, envelope de erro do `-o json`, a UI
`/settings/ai` no navegador, troca de IA no meio de um agente real. Armadilhas: gotchas, itens 168–172.
+70 -11
View File
@@ -8,7 +8,7 @@ cena é montada **por peças** a partir do texto (parque de dia, cemitério, bun
criados uma vez, na biblioteca, e reaproveitados em várias histórias. Não crie "cena pronta" nova; crie peça ou regra. criados uma vez, na biblioteca, e reaproveitados em várias histórias. Não crie "cena pronta" nova; crie peça ou regra.
Guias do projeto (fonte de detalhe, não duplicar aqui): `doc/cartoon/cenas.md` (camadas, receitas por situação, Guias do projeto (fonte de detalhe, não duplicar aqui): `doc/cartoon/cenas.md` (camadas, receitas por situação,
composição), `doc/cartoon/personagens.md` (ficha, agente), estudo de referência `doc/estudo-estilo-cartoon-explicativo.md`. composição), `doc/cartoon/personagens.md` (ficha, agente), `doc/cartoon/animacao.md` (expressões e movimento, guia do agente), estudo de referência `doc/estudo-estilo-cartoon-explicativo.md`.
## Contrato da cena (`cartoon/src/spec.ts`, `schemaVersion` 1; `validateSpec` recusa o resto) ## Contrato da cena (`cartoon/src/spec.ts`, `schemaVersion` 1; `validateSpec` recusa o resto)
@@ -22,7 +22,11 @@ composição), `doc/cartoon/personagens.md` (ficha, agente), estudo de referênc
`z` 0 = frente, 1 = fundo. 24 peças em `ELEMENTS`: tree, deadtree, pine, bush, rock, mountain, cloud, bench, lamp, `z` 0 = frente, 1 = fundo. 24 peças em `ELEMENTS`: tree, deadtree, pine, bush, rock, mountain, cloud, bench, lamp,
gravestone, cross, fence, house, building, car, sign, door, window, table, bed, shelf, crate, tent, fire. gravestone, cross, fence, house, building, car, sign, door, window, table, bed, shelf, crate, tent, fire.
Peça nova = entrada em `ELEMENTS` + desenho em `cartoon/src/places.tsx`. Peça nova = entrada em `ELEMENTS` + desenho em `cartoon/src/places.tsx`.
- `actors`: `person` com `character {name, caption, look}`, `expression`, `pose`, `item` (objeto na mão), `flip` - `grain` (0 desliga, padrão 0,11): textura de papel sobre a cena (`Grain` em `overlays.tsx`, feTurbulence com mix-blend overlay;
também no `CharacterCard`).
- `actors`: `person` com `character {name, caption, look}`, `expression`, `pose`, `item` (objeto na mão), `flip`,
`framing` `full|medium|close` (Shot: zoom 1/1,9/2,9 e base y = `y`/0,98/1,15; a etiqueta vai para o lado),
`face`/`body` (ajustes finos do rig), `timeline` (ações de movimento, até 40); `spec.audioEnv {fps, values}`
(campos antigos `label`/`hair`/`glasses`/`pointing` ainda valem); `crowd` (entra antes do personagem, atrás, pés em y 0,6). (campos antigos `label`/`hair`/`glasses`/`pointing` ainda valem); `crowd` (entra antes do personagem, atrás, pés em y 0,6).
## Peças (`cartoon/src/`) ## Peças (`cartoon/src/`)
@@ -46,22 +50,61 @@ personagem:** `tsx cartoon/render.ts --still --props x.json --out y.png [--frame
- **Contrato** `cartoon/src/character.ts` (`Character`, `schemaVersion` 1): `id`, `name`, `caption`, `description`, - **Contrato** `cartoon/src/character.ts` (`Character`, `schemaVersion` 1): `id`, `name`, `caption`, `description`,
`kind` `cartoon|3d`, `look {build slim|average|heavy, height 0,6–1,2, skin, hair{style short|side|bun|long|curly|spiky| `kind` `cartoon|3d`, `look {build slim|average|heavy, height 0,6–1,2, skin, hair{style short|side|bun|long|curly|spiky|
bald|cap, color}, beard none|stubble|mustache|full|goatee, glasses none|round|square|sun, brows thin|thick, bald|cap, color}, beard none|stubble|mustache|full|goatee, glasses none|round|square|sun, brows thin|thick,
top{shirt|jacket|hoodie|dress|uniform, color, accent}, bottom pants|shorts|skirt, shoes}`. `EXPRESSIONS`: neutral, happy, top{shirt|jacket|hoodie|dress|uniform, color, accent}, bottom pants|shorts|skirt, shoes}`. `EXPRESSIONS`/`POSES`
sad, worried, angry, surprised, scared. `POSES`: stand, point, wave, hold, arms_up, shrug, think. `validateLook`. vêm do rig (reexportados). `validateLook`.
- **Desenho** `CharacterFigure.tsx`: SVG puro (sem Remotion), `viewBox` 200×440, pés em (100,440); `t` anima respirar, **Acabamento (17/11/2026), campos OPCIONAIS do `look`:** `head` (`HEAD_SHAPES` round|oval|square|wide), `nose` (`NOSES`
piscar e acenar. O painel importa o mesmo componente (prévia ao vivo): dependência `"cenaforge-cartoon": "workspace:*"` em button|curve|round|long|wide), `lids` (0–0,8, pálpebra de base), `wrinkles` (0–1), `belly` (bool), `accessories`
`panel/package.json`, `transpilePackages` em `panel/next.config.ts`, `exports` do pacote `./character`, `./figure`, `./spec`. (`ACCESSORIES`: towel, whistle, tie, vest, helmet, watch, badge, apron, scarf, headset, chain) e `accessoryColor`.
- **Desenho** `CharacterFigure.tsx`: SVG puro (sem Remotion), `viewBox` 200×440, pés em (100,440), escrito sobre o rig (seção
"Rig, movimento e fala"). O painel importa o mesmo componente (prévia ao vivo): dependência `"cenaforge-cartoon": "workspace:*"` em
`panel/package.json`, `transpilePackages` em `panel/next.config.ts`, `exports` do pacote `./character`, `./figure`, `./spec`, `./motion`, `./rig`.
- **Arquivos:** `assets/characters/<id>/character.json`; elenco da história `stories/<id>/cast.json` (`{"cast":[ids]}`). - **Arquivos:** `assets/characters/<id>/character.json`; elenco da história `stories/<id>/cast.json` (`{"cast":[ids]}`).
- **Painel** `panel/src/lib/characters.ts`: `listCharacters`/`getCharacter`/`saveCharacter`/`deleteCharacter` (não apaga - **Painel** `panel/src/lib/characters.ts`: `listCharacters`/`getCharacter`/`saveCharacter`/`deleteCharacter` (não apaga
quem está em elenco), `describeToLook` (descrição pt-BR → `look` + `caption` por regras: idade, gênero, criança, quem está em elenco), `describeToLook` (descrição pt-BR → `look` + `caption` por regras: idade, gênero, criança,
profissão → uniforme/cor, cabelo, barba, óculos, corpo, cor de roupa), `getCast`/`setCast`. Rotas: `GET/POST profissão → uniforme/cor, cabelo, barba, óculos, corpo, cor de roupa; **e o acabamento**: `nose`, `lids`, `wrinkles`,
`head`, `belly` e `accessories` por idade, "barrigudo", "narigudo", "cansado" e profissão — técnico: apito + relógio;
obra: capacete + colete laranja; porteiro: crachá; merendeira: avental; roupeiro: toalha; empresário: gravata + relógio;
`PROFESSIONS` inclui técnico, porteiro, merendeira, roupeiro, operário, empresário), `getCast`/`setCast`. Rotas: `GET/POST
/api/characters`, `GET/PUT/DELETE /api/characters/[id]`, `POST /api/characters/[id]/agent`, `GET/PUT /api/characters`, `GET/PUT/DELETE /api/characters/[id]`, `POST /api/characters/[id]/agent`, `GET/PUT
/api/stories/[storyId]/cast`. Página `/characters` (aba "Personagens"; `components/character-studio.tsx`: criar pela /api/stories/[storyId]/cast`. Página `/characters` (aba "Personagens"; `components/character-studio.tsx`: criar pela
descrição, prévia com expressão/pose, formulário peça por peça, "Refinar com o agente", apagar). descrição, prévia com expressão/pose, formulário peça por peça — inclui Cabeça, Nariz, Pálpebra, Rugas, Barriga, Cor dos acessórios e chips de Acessórios —,
"Refinar com o agente", apagar).
- **Agente:** `AgentKind` `"character"` (`types.ts`; `agents.ts`: orçamento US$ 0,5, Sonnet, Claude preferido; `prompts.ts` - **Agente:** `AgentKind` `"character"` (`types.ts`; `agents.ts`: orçamento US$ 0,5, Sonnet, Claude preferido; `prompts.ts`
manda ler SÓ `doc/cartoon/personagens.md` e gravar a ficha). manda ler SÓ `doc/cartoon/personagens.md` e gravar a ficha).
- Para testar a API com acento use Python/UTF-8 (gotchas 153); o `id` sai do nome sem acento. - Para testar a API com acento use Python/UTF-8 (gotchas 153); o `id` sai do nome sem acento.
## Rig, movimento e fala (FERRAMENTA, não template)
Princípio do dono: expressão e movimento são **parâmetros contínuos e ações combináveis**; os presets são só atalhos.
Detalhe e exemplos: `doc/cartoon/animacao.md`.
- **`rig.ts`:** `FaceParams` (`browL/browR {y, tilt}` tilt + = ponta de dentro sobe, `eyeL/eyeR` 0–1,35, `pupil`,
`gazeX/gazeY`, `mouthOpen`, `smile` −1…1, `mouthWidth`, `mouthRound`, `lid` (pálpebra, somada ao `lids` do personagem: surpreso/medo −0,5, sono 0,6, desconfiado 0,45; os presets usam `lid` em vez de fechar o olho), `teeth`, `blush`, `sweat`, `tears`, `anger`) e
`BodyParams` (`lean`, `headTilt`, `headTurn` −1…1, `headNod`, `armL/armR/legL/legR {raise, bend}` em 2 segmentos, `crouch`).
20 `EXPRESSION_PRESETS` (neutral, smile, happy, laugh, proud, sad, cry, worried, angry, furious, surprised, scared,
shocked, suspicious, smirk, confused, disgusted, sleepy, determined, embarrassed) e 17 `POSE_PRESETS` (stand, point, wave,
hold, arms_up, celebrate, shrug, think, hands_on_hips, cross_arms, facepalm, cover_mouth, defend, reach, sit, kneel,
lean_in). `faceOf`/`bodyOf(nome, ajuste)`, `withFace`/`withBody` (aceitam `brows`/`eyes`/`arms`/`legs`), `blendFace`/`blendBody`.
- **`motion.ts`:** `Action {do, at|atP|cue, dur, cueEnd, expression/face, pose/body, to, dir, times, height, text}`; `ACTIONS`:
express, pose, walk, run, enter, exit, jump, nod, shake_head, tremble, bounce, fall, sit, stand_up, turn, talk, look, emote,
wave. `evaluate(actor, t, durationS, seed, {words, env})` → `{face, body, x, dx, dy, rot, sx, sy, flip, emote}`; `startOf`
resolve `cue` pela palavra falada (prefixo normalizado); piscar em intervalos variados, respirar e balanço sempre ligados;
`validateTimeline` (até 40 ações). `Shot.tsx` aplica `evaluate` por ator (posição/giro/escala/espelho no container).
- **`lipsync.ts`:** `visemeAt(palavras, t, env)` (forma por letra: a abre, e/i esticam, o/u arredondam, m/b/p fecham, f/v
dentes; vogal pesa 1,7 e consoante 0,8; coarticulação na 2ª metade da letra; fecha 60 ms após a palavra; `env` fecha nas
pausas), `emphasisAt` (sobrancelhas no pico), `speak(face, viseme)` (mantém cantos/sobrancelhas/olhos da expressão). `talk`
usa as palavras entre `cue` e `cueEnd`, ou `text` repartido por `dur`.
- **Desenho:** prop `state` (de `evaluate`); sem ele usa `expression`/`pose` + vida. Boca contínua com `clipPath`; olho de
riso em arco; balão de emote; mão no rosto desenhada por cima da cabeça. **Acabamento do desenho:** pálpebra recortada
(`clipPath` por olho) com borda mais escura; 5 narizes; rugas; cabeça por formato (`headPath`) com sombra de baixo e
brilho na testa; orelha com dobra; mão com polegar; tronco com sombra lateral, gola em V e zíper; barriga = elipse + curva
de volume (**só a sombra em elipse parecia mancha**); `Accessories` (capacete e fone na cabeça, relógio no pulso esquerdo).
**Armadilha:** a curva quadrática só chega à
METADE do controle, então os controles da boca ficam no dobro da abertura.
- **Painel:** `character-studio.tsx` lista as 20 expressões e 17 poses em pt-BR e tem "Movimento (prévia)" (`MovePreview`,
loop de 2,6 s). `CharacterCard` aceita framing `"face"` (recorte do rosto). Agente `character` lê `animacao.md` se o
pedido falar de expressão/movimento.
## Plano no painel (`panel/src/lib/montage-cartoon.ts`, sem banco) ## Plano no painel (`panel/src/lib/montage-cartoon.ts`, sem banco)
- Tipos vêm de `"cenaforge-cartoon/spec"` (não há mais espelho). `planCartoon(shot, ctx, variant)` com - Tipos vêm de `"cenaforge-cartoon/spec"` (não há mais espelho). `planCartoon(shot, ctx, variant)` com
@@ -71,6 +114,8 @@ personagem:** `tsx cartoon/render.ts --still --props x.json --out y.png [--frame
paleta/luz própria). Sem lugar reconhecido cai nas cenas antigas. paleta/luz própria). Sem lugar reconhecido cai nas cenas antigas.
- **Personagem:** `expressionOf`/`poseOf` pelo texto; quem é citado pelo nome entra com a aparência da biblioteca; com 1 - **Personagem:** `expressionOf`/`poseOf` pelo texto; quem é citado pelo nome entra com a aparência da biblioteca; com 1
personagem só, ele aparece nos trechos pares ou quando o texto diz "ele/ela"; objeto pequeno vai para a mão (`item`). personagem só, ele aparece nos trechos pares ou quando o texto diz "ele/ela"; objeto pequeno vai para a mão (`item`).
- **Enquadramento do personagem** (`framing`): `close` quando ele fala sozinho (há `talk`, 1 personagem); `medium` sozinho
sem objetos nem multidão; `full` no resto.
- Ícones por palavra-chave; "pessoas/vizinhos" vira multidão; "nunca/não" + perigo risca o objeto; sons viram - Ícones por palavra-chave; "pessoas/vizinhos" vira multidão; "nunca/não" + perigo risca o objeto; sons viram
onomatopeia (motor só com gerador/motor/moto/carro perto; barulho genérico = "Crec"); texto na tela numérico vira `big`, onomatopeia (motor só com gerador/motor/moto/carro perto; barulho genérico = "Crec"); texto na tela numérico vira `big`,
senão etiqueta; `variant` troca arranjo e seed. senão etiqueta; `variant` troca arranjo e seed.
@@ -85,13 +130,27 @@ personagem:** `tsx cartoon/render.ts --still --props x.json --out y.png [--frame
geração); "Gerar de novo" troca `cartoonVariant`; `hudFor` = 2 primeiras palavras do título + "Ep. N". geração); "Gerar de novo" troca `cartoonVariant`; `hudFor` = 2 primeiras palavras do título + "Ep. N".
- **UI** (`montage-editor.tsx`, recebe `storyId`): opção de estilo, bloco `CartoonSetup` (paleta da série + elenco por chips, - **UI** (`montage-editor.tsx`, recebe `storyId`): opção de estilo, bloco `CartoonSetup` (paleta da série + elenco por chips,
só no estilo Cartoon), botão "Cartoon" no trecho, `CartoonPreview`. só no estilo Cartoon), botão "Cartoon" no trecho, `CartoonPreview`.
- **Testes:** `panel/src/lib/montage-cartoon.test.ts` (9). - **Movimento pelo texto:** `timelineFor(texto, x)` (`EMOTIONS` por palavra → `express` com `cue`; `MOVES` por verbo → ações;
`quoteOf`: fala entre aspas/travessão → `talk` com `cue`/`cueEnd`; começa `neutral` se houver `express`).
`audioEnvelope(file)` (FFmpeg mono 8 kHz, RMS por quadro normalizado pelo p95; ~199 quadros para 6,6 s) →
`cartoonSpec(scene, dur, words, env)`; `montage.ts` passa o env.
- **Testes:** `panel/src/lib/montage-cartoon.test.ts` (10).
## Medido (17/11/2026) ## Medido (17/11/2026)
Mesmo personagem em parque (`day`), cemitério (`dusk` + fog + `vignette`) e bunker (`sepia` + `spot` + indoor): 3 trechos de Mesmo personagem em parque (`day`), cemitério (`dusk` + fog + `vignette`) e bunker (`sepia` + `spot` + indoor): 3 trechos de
4 s em ~2,6–2,8 s cada. Plano com elenco "Marta" → parque de dia (acenando) e cemitério (com medo, "Crec") renderizados. 4 s em ~2,6–2,8 s cada. Plano com elenco "Marta" → parque de dia (acenando) e cemitério (com medo, "Crec") renderizados.
Testes: painel 77/77, cartoon 5/5; `tsc` ok nos dois (informados pelo dono; cartoon 5/5 reexecutado na skill). Testes (antes do rig): painel 77/77, cartoon 5/5.
Rig/movimento (17/11/2026, informado pelo dono): grade das 20 expressões conferida de perto; personagem falando narração
real (ilha ep01-01) com `worried` mantida e "não" balançando a cabeça na palavra; sequência enter→jump→sit→stand_up→wave→
scared+"!"→tremble→fall de 7 s renderizada em 5,6 s. Testes: painel 78/78 e `tsc` ok (informados); cartoon 16/16
(`tests/motion.test.ts` 11 novos) reexecutado na skill. Renders não reexecutados.
Acabamento de ilustração (17/11/2026, informado pelo dono; referência: reel de série de cartoon, cujos personagens são
ilustrações paradas com textura, só a câmera desliza — o rig mantém a animação): 4 personagens criados só pela descrição
(porteiro 64, técnico barrigudo 52, mestre de obra 38, merendeira 70) saíram com os detalhes certos; close falando
renderizado. Testes: cartoon 16/16 reexecutado na skill; painel 78/78 e `tsc` informados. Renders não reexecutados.
## Ainda não existe (próximo passo) ## Ainda não existe (próximo passo)
+77 -20
View File
@@ -12,7 +12,7 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
| O quê | Onde | | O quê | Onde |
|---|---| |---|---|
| Banco do Clipador | `data/clipper/clipper.db` (`PRAGMA user_version` 10, `SCHEMA` em `clipper/app/db.py`: v1 tabelas, v2 `settings`, v3 jogo/varredura/emotes/configuração do corte — colunas novas em `sessions`, `channels.settings_json`, `chat.emotes`, `clips.learned`, tabelas `games` e `emotes`; v4 `edits` (`clip_id`, `project_json`, `rev`, `cover`, `exported_at`, `created_at`, `updated_at`); v5 `face_track`; v6 `games.notes_json`/`games.edited_at`; v7 `edits.origin` (`ai`/`user`) + `edits.ai_project_json`; v8 `clips.aspect` (`vertical`/`horizontal`, padrão `vertical`, gravado no render); v9 `sessions.capture_json` (o que a captura gravou de fato; sessões antigas `NULL`); v10 tabela `deleted_clips` (marca do corte apagado, `ON DELETE CASCADE` com a sessão)). Migra ao subir o serviço. **Nunca altere uma migração já aplicada** (o banco real estava em v4 quando a v7 nasceu): coluna nova = `ALTER` numa versão nova | | Banco do Clipador | `data/clipper/clipper.db` (`PRAGMA user_version` 12, `SCHEMA` em `clipper/app/db.py`: v1 tabelas, v2 `settings`, v3 jogo/varredura/emotes/configuração do corte — colunas novas em `sessions`, `channels.settings_json`, `chat.emotes`, `clips.learned`, tabelas `games` e `emotes`; v4 `edits` (`clip_id`, `project_json`, `rev`, `cover`, `exported_at`, `created_at`, `updated_at`); v5 `face_track`; v6 `games.notes_json`/`games.edited_at`; v7 `edits.origin` (`ai`/`user`) + `edits.ai_project_json`; v8 `clips.aspect` (`vertical`/`horizontal`, padrão `vertical`, gravado no render); v9 `sessions.capture_json` (o que a captura gravou de fato; sessões antigas `NULL`); v10 tabela `deleted_clips` (marca do corte apagado, `ON DELETE CASCADE` com a sessão); v11 `channels.monitor_paused_at`/`monitor_paused_session`/`language` e `sessions.language`, padrão `''` = `CLIPPER_LANGUAGE`; v12 `games.profile_ai_json` (perfil em inglês), `translated_at`, `aliases_json`). Migra ao subir o serviço. **Nunca altere uma migração já aplicada** (o banco real estava em v4 quando a v7 nasceu): coluna nova = `ALTER` numa versão nova |
| Blocos gravados (`.ts` de 30 s + `segments.csv`) e frames | `data/clipper/sessions/<id>/` (frames em `frames/`) | | Blocos gravados (`.ts` de 30 s + `segments.csv`) e frames | `data/clipper/sessions/<id>/` (frames em `frames/`) |
| Pesos do rastreio de reação (YuNet, MediaPipe, OpenSeeFace) | `data/clipper/models/`, fixados (URL imutável + sha256) em `clipper/models.lock.json` | | Pesos do rastreio de reação (YuNet, MediaPipe, OpenSeeFace) | `data/clipper/models/`, fixados (URL imutável + sha256) em `clipper/models.lock.json` |
| Cortes prontos | `output/clipper/<sessão>/clip-<id>.mp4` + `clip-<id>.jpg` | | Cortes prontos | `output/clipper/<sessão>/clip-<id>.mp4` + `clip-<id>.jpg` |
@@ -29,12 +29,13 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
| Busca de quadro dentro de bloco `.ts` (`seek_args`, `grab_frame`) e emenda de resolução/codec (`uniform_segments`) | `clipper/app/media.py`; `clipper/app/editor_render.py`; `face.grab_bgr` e tamanho do quadro por bloco (`_frame_size`) em `face.py` | gotchas, itens 107–108 | | Busca de quadro dentro de bloco `.ts` (`seek_args`, `grab_frame`) e emenda de resolução/codec (`uniform_segments`) | `clipper/app/media.py`; `clipper/app/editor_render.py`; `face.grab_bgr` e tamanho do quadro por bloco (`_frame_size`) em `face.py` | gotchas, itens 107–108 |
| Retomada de live (`Engine.live_check`, `keep_live`, `RESUME_DELAYS_S`, `resume_interrupted`), render que falha (`recover_orphan_renders`, `ORPHAN_RENDER_S` 300, `MAX_RENDER_ATTEMPTS` 3), cortes duplicados (`SAME_PEAK_S` 10, `SAME_MOMENT_OVERLAP` 0,6, `KEPT_STATUSES`/`VETO_STATUSES`, `discard_pending_duplicates`) | `clipper/app/worker.py` | `clipper/tests/test_resume.py`, `clipper/tests/test_render_and_duplicates.py` | | Retomada de live (`Engine.live_check`, `keep_live`, `RESUME_DELAYS_S`, `resume_interrupted`), render que falha (`recover_orphan_renders`, `ORPHAN_RENDER_S` 300, `MAX_RENDER_ATTEMPTS` 3), cortes duplicados (`SAME_PEAK_S` 10, `SAME_MOMENT_OVERLAP` 0,6, `KEPT_STATUSES`/`VETO_STATUSES`, `discard_pending_duplicates`) | `clipper/app/worker.py` | `clipper/tests/test_resume.py`, `clipper/tests/test_render_and_duplicates.py` |
| Apagar cortes (`delete_clip`, `delete_many`, `select_ids`, `MAX_BATCH` 500, recusas `BUSY`/`PUBLISHED`/`CHANGED`, marca `marks`/`mark_spans`, arquivos só dentro das pastas do Clipador) | `clipper/app/clip_delete.py`; rotas em `main.py` (`ClipsDeleteIn`); marca lida em `worker.py` (veto depois do juiz) e na varredura (`intel.py`) | `clipper/tests/test_clip_delete.py`; `METHODS` em `panel/src/lib/clipper.ts`; seção "Apagar cortes" abaixo | | Apagar cortes (`delete_clip`, `delete_many`, `select_ids`, `MAX_BATCH` 500, recusas `BUSY`/`PUBLISHED`/`CHANGED`, marca `marks`/`mark_spans`, arquivos só dentro das pastas do Clipador) | `clipper/app/clip_delete.py`; rotas em `main.py` (`ClipsDeleteIn`); marca lida em `worker.py` (veto depois do juiz) e na varredura (`intel.py`) | `clipper/tests/test_clip_delete.py`; `METHODS` em `panel/src/lib/clipper.ts`; seção "Apagar cortes" abaixo |
| Parar à mão e pausa do monitor (`Engine.stop_session(id, pause_monitor=True)`, `StopIn.pauseMonitor`), idioma por fonte/sessão (`check_language`, visões de fonte/sessão/corte com `language` resolvido; Whisper e `judge.output_language_note`) | `clipper/app/worker.py`, `main.py`, `db.py` (v11), `judge.py`; painel `ACCOUNT_LANGUAGES` em `panel/src/lib/languages.ts` | `clipper/tests/test_monitor_pause_and_language.py` (9); seção "Parar é parar e idioma" abaixo |
| Chat (IRC anônimo da Twitch com `CAP REQ :twitch.tv/tags` → emotes nativos e `room-id`; Pusher da Kick, emotes `[emote:id:NOME]`) | `clipper/app/chat.py` | — | | Chat (IRC anônimo da Twitch com `CAP REQ :twitch.tv/tags` → emotes nativos e `room-id`; Pusher da Kick, emotes `[emote:id:NOME]`) | `clipper/app/chat.py` | — |
| Heurística: pesos, base de 3 min, mínimo proporcional (`_required_messages`), reações (`min_reactions`), chat fraco (`sparse_rate` 0,5 msg/s), momentos do chat/áudio/rosto (`_chat_moments`/`_audio_moments`/`_face_moments`; `face_*` em `Params`), `pick_peaks`, `fit_window` (duração de todo corte automático) | `Params` e funções em `clipper/app/scoring.py`; alvo `min_target` em `layout.py` | `clipper/tests/test_scoring.py` (regressões de falso positivo, chat fraco e rosto), `test_duration_banner_fonts.py` | | Heurística: pesos, base de 3 min, mínimo proporcional (`_required_messages`), reações (`min_reactions`), chat fraco (`sparse_rate` 0,5 msg/s), momentos do chat/áudio/rosto (`_chat_moments`/`_audio_moments`/`_face_moments`; `face_*` em `Params`), `pick_peaks`, `fit_window` (duração de todo corte automático) | `Params` e funções em `clipper/app/scoring.py`; alvo `min_target` em `layout.py` | `clipper/tests/test_scoring.py` (regressões de falso positivo, chat fraco e rosto), `test_duration_banner_fonts.py` |
| Rastreio de reação — E/S: backends (MediaPipe; plano B OpenSeeFace), download sob demanda com sha256, recorte FFmpeg 6 qps, laço `face` | `clipper/app/face.py` (`for_scoring`, `must_wait`, `view`, `reset`); laço `_face_loop` e uso de `must_wait` na decisão do corte em `worker.py`; bancada `clipper/tools/face_bench.py` | `clipper/tests/test_face.py`, `clipper/models.lock.json`, `doc/FACE_BAKEOFF.md` | | Rastreio de reação — E/S: backends (MediaPipe; plano B OpenSeeFace), download sob demanda com sha256, recorte FFmpeg 6 qps, laço `face` | `clipper/app/face.py` (`for_scoring`, `must_wait`, `view`, `reset`); laço `_face_loop` e uso de `must_wait` na decisão do corte em `worker.py`; bancada `clipper/tools/face_bench.py` | `clipper/tests/test_face.py`, `clipper/models.lock.json`, `doc/FACE_BAKEOFF.md` |
| Rastreio de reação — lógica pura: sinal por segundo contra o neutro do streamer, rótulos, `reaction_moments`, `summarize` (linha do analista), `locate_cam` (câmera pelo rosto) | `ReactionParams` e funções em `clipper/app/reaction.py` | `clipper/tests/test_reaction.py` | | Rastreio de reação — lógica pura: sinal por segundo contra o neutro do streamer, rótulos, `reaction_moments`, `summarize` (linha do analista), `locate_cam` (câmera pelo rosto) | `ReactionParams` e funções em `clipper/app/reaction.py` | `clipper/tests/test_reaction.py` |
| Emotes: catálogo 7TV/BTTV/FFZ (canal + global, TTL 1 h, fonte que falha é ignorada), emojis, peso aprendido (`LEARN_UP`/`LEARN_DOWN` 0,3/0,15) | `clipper/app/emotes.py`; ingestão e aprendizado em `clipper/app/intel.py` (`ingest_chat`, `learn_from_clip`) | `clipper/tests/test_intel.py` | | Emotes: catálogo 7TV/BTTV/FFZ (canal + global, TTL 1 h, fonte que falha é ignorada), emojis, peso aprendido (`LEARN_UP`/`LEARN_DOWN` 0,3/0,15) | `clipper/app/emotes.py`; ingestão e aprendizado em `clipper/app/intel.py` (`ingest_chat`, `learn_from_clip`) | `clipper/tests/test_intel.py` |
| Contexto do jogo (categoria a cada `GAME_CHECK_S` 600, `screen_game`, perfil pela web; `clean_profile`, `save_profile`, `refine`, `delete_note`), varredura (`SCAN_*`), webcam (`detect_cam`: YuNet local primeiro, IA só se não achar ou `use_ai`; `CAM_RETRY_S` 300), opções `OPTION_DEFAULTS` (inclui `faceTrack`) | `clipper/app/intel.py` | README do Clipador | | Contexto do jogo (categoria a cada `GAME_CHECK_S` 600, `screen_game`, perfil pela web; `clean_profile`, `save_profile`, `refine`, `delete_note`; perfis bilíngues, `add_game`, `delete_game`, `translate`, aliases, `import_seeds` de `clipper/app/seeds/games/*.json`; contrato em `doc/clipador/JOGOS.md`), varredura (`SCAN_*`), webcam (`detect_cam`: YuNet local primeiro, IA só se não achar ou `use_ai`; `CAM_RETRY_S` 300), opções `OPTION_DEFAULTS` (inclui `faceTrack`) | `clipper/app/intel.py` | README do Clipador |
| Juízes (analista + editor), prompts, glossário `CHAT_GLOSSARY`, linha "Rosto do streamer: …" do analista, schemas, chamada da CLI, pesquisa e refino do jogo (`PROFILE_SYSTEM`/`research_game`, `REFINE_SYSTEM`/`refine_game`), câmera | `clipper/app/judge.py`; montagem dos 6 frames do analista (8 se o trecho passa de 80 s) em `worker.py` | README do Clipador | | Juízes (analista + editor), prompts, glossário `CHAT_GLOSSARY`, linha "Rosto do streamer: …" do analista, schemas, chamada da CLI, pesquisa e refino do jogo (`PROFILE_SYSTEM`/`research_game`, `REFINE_SYSTEM`/`refine_game`), câmera | `clipper/app/judge.py`; montagem dos 6 frames do analista (8 se o trecho passa de 80 s) em `worker.py` | README do Clipador |
| Hashtags da legenda (`to_tag`, `fold`, `split_hashtags`, `compose`, `build_caption`; `MAX_TAGS` 8, `GAME_TAGS` 3, `MOMENT_TAGS` 4) | `clipper/app/hashtags.py`; uso em `judge_clip` de `worker.py`; campo `hashtags` em `judge.py` (`VERDICT_SCHEMA`, `PROFILE_SCHEMA`, `Verdict.hashtags`) e `PROFILE_LISTS`/`clean_profile`/`Intel.session_game` em `intel.py` — ver "Hashtags da legenda" abaixo | `clipper/tests/test_hashtags.py` | | Hashtags da legenda (`to_tag`, `fold`, `split_hashtags`, `compose`, `build_caption`; `MAX_TAGS` 8, `GAME_TAGS` 3, `MOMENT_TAGS` 4) | `clipper/app/hashtags.py`; uso em `judge_clip` de `worker.py`; campo `hashtags` em `judge.py` (`VERDICT_SCHEMA`, `PROFILE_SCHEMA`, `Verdict.hashtags`) e `PROFILE_LISTS`/`clean_profile`/`Intel.session_game` em `intel.py` — ver "Hashtags da legenda" abaixo | `clipper/tests/test_hashtags.py` |
| Configuração do corte: camadas padrão ← canal ← sessão ← projeto (`DEFAULTS`, `merge`, `validate`), `format.aspect` (`ASPECTS`, `FRAME_SIZES`, `CANVAS_SIZES`, `aspect()`), `MODES` (5 modos, inclui `cam_only`), `resolved_mode` (queda para `blur` sem câmera; `full` no horizontal), retângulos, legenda, crédito, `duration` (`min_target`), `hook` (`HOOK_STYLES`, `HOOK_ANIMS`, `HOOK_FONT`), `capture`; fontes empacotadas (`PACKAGED_FONTS`, `font_files`, `ass_filter` = `ass=` com `fontsdir` só se o ASS usar uma delas); cadeia de layout reutilizável `layout_chain(settings, src, dst, tail, suffix, mode)` (usada por `video_filter` e pelo editor) | `clipper/app/layout.py`; rotas de settings em `main.py` (devolvem `aspects`, `frames`, `fontFiles`, `hookStyles`, `hookAnims` e `captureQualities`) | `clipper/tests/test_format_and_captions.py` (o vertical precisa continuar batendo com `clipper/tests/data/vertical_golden_sha256.json`); modo novo também em `LayoutMode`/`MODE_LABEL` de `panel/src/components/clipper-client.ts` e `resolvedMode` de `clip-editor-model.ts`; grupo novo também em `CutSettings` (`Aspect`, `aspectOf`, `withFormat` para serviço antigo) | | Configuração do corte: camadas padrão ← canal ← sessão ← projeto (`DEFAULTS`, `merge`, `validate`), `format.aspect` (`ASPECTS`, `FRAME_SIZES`, `CANVAS_SIZES`, `aspect()`), `MODES` (5 modos, inclui `cam_only`), `resolved_mode` (queda para `blur` sem câmera; `full` no horizontal), retângulos, legenda, crédito, `duration` (`min_target`), `hook` (`HOOK_STYLES`, `HOOK_ANIMS`, `HOOK_FONT`), `capture`; fontes empacotadas (`PACKAGED_FONTS`, `font_files`, `ass_filter` = `ass=` com `fontsdir` só se o ASS usar uma delas); cadeia de layout reutilizável `layout_chain(settings, src, dst, tail, suffix, mode)` (usada por `video_filter` e pelo editor) | `clipper/app/layout.py`; rotas de settings em `main.py` (devolvem `aspects`, `frames`, `fontFiles`, `hookStyles`, `hookAnims` e `captureQualities`) | `clipper/tests/test_format_and_captions.py` (o vertical precisa continuar batendo com `clipper/tests/data/vertical_golden_sha256.json`); modo novo também em `LayoutMode`/`MODE_LABEL` de `panel/src/components/clipper-client.ts` e `resolvedMode` de `clip-editor-model.ts`; grupo novo também em `CutSettings` (`Aspect`, `aspectOf`, `withFormat` para serviço antigo) |
@@ -45,7 +46,7 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
| Legenda (tempo saneado: `clean_words`, `group_words`, `caption_blocks`; `build_ass`) e crédito — usada pelo render do editor e pelo worker, nos dois formatos | `clipper/app/subtitles.py` (`MIN_WORD_S` 0,06, `MIN_STEP_S` 0,04). `media.render_vertical` ainda existe em `media.py`, mas **não** é mais usado pelo render de cortes | `clipper/tests/test_format_and_captions.py`; [gotchas.md](gotchas.md) itens 57–58, 70, 90 | | Legenda (tempo saneado: `clean_words`, `group_words`, `caption_blocks`; `build_ass`) e crédito — usada pelo render do editor e pelo worker, nos dois formatos | `clipper/app/subtitles.py` (`MIN_WORD_S` 0,06, `MIN_STEP_S` 0,04). `media.render_vertical` ainda existe em `media.py`, mas **não** é mais usado pelo render de cortes | `clipper/tests/test_format_and_captions.py`; [gotchas.md](gotchas.md) itens 57–58, 70, 90 |
| Rotas HTTP | `clipper/app/main.py` (editor: `editor_api.py`) | `ALLOWED` em `panel/src/lib/clipper.ts` (o proxy recusa caminho fora da regex) e o timeout por rota no mesmo arquivo | | Rotas HTTP | `clipper/app/main.py` (editor: `editor_api.py`) | `ALLOWED` em `panel/src/lib/clipper.ts` (o proxy recusa caminho fora da regex) e o timeout por rota no mesmo arquivo |
| Variáveis do `.env` | `clipper/app/config.py` + `clipper/.env.example` | tabela do README do Clipador | | Variáveis do `.env` | `clipper/app/config.py` + `clipper/.env.example` | tabela do README do Clipador |
| Página `/clipper` | `panel/src/app/clipper/page.tsx`, `panel/src/components/clipper-*.tsx` (`clipper-cut-settings.tsx` modal do corte em 5 abas, com Gancho e "Qualidade da gravação"; `clipper-games.tsx` aba Jogos e emotes (editar perfil, pedir à IA, pedidos guardados); `clipper-queue.tsx` cartão com a análise, reação do rosto (`FaceSignal`, `FACE_LABEL`), recuo do início `START_STEPS`, botão "Editar"/"Continuar edição", "Apagar" e seleção discreta (`SelectionPill`); `clipper-judge.tsx` interruptor "Rastrear a reação do streamer"; `clipper-sessions.tsx` cartão da sessão (`sessionHealth`, selo de quem achou a câmera, relógio `RecordingClock`, cadência `SummaryCadence`) e cabeçalho em `clipper-studio.tsx`), cliente `clipper-client.ts` | [panel.md](panel.md) | | Páginas `/clipper/*` (grupo de rotas `panel/src/app/clipper/(studio)/`, layout com `ClipperProvider` + `ClipperShell`) | `clipper-provider.tsx` (dados + consulta periódica, `useClipper()`), `clipper-shell.tsx` (`CLIPPER_SECTIONS`, cabeçalho, bloco "Ao vivo agora · N"), páginas `clipper-clips-page.tsx` (+ `clipper-clip-table.tsx` `ClipTable`, `clipper-clip-dialog.tsx` `ClipDialog`, `clipper-clip-parts.tsx`), `clipper-sessions-page.tsx`, `clipper-session-detail.tsx`, `clipper-channels.tsx` (Fontes), `clipper-games-page.tsx` + `clipper-game-dialog.tsx` + `clipper-game-parts.tsx` + `clipper-games.tsx` (emotes), `clipper-settings-page.tsx`; peças compartilhadas em `clipper-sessions.tsx` (`PlatformIcon`, `CutNow`, `RecordForm`, relógio, `sessionHealth`) e utilitários da lista em `clipper-queue.tsx`; `clipper-cut-settings.tsx` modal do corte em 5 abas; `clipper-judge.tsx`; cliente `clipper-client.ts`. Mapa de rotas e papéis em [panel.md](panel.md#página-clipper-clipador) | [panel.md](panel.md) |
| Página do editor `/clipper/edit/[clipId]` | `panel/src/app/clipper/edit/[clipId]/page.tsx` + `panel/src/components/clip-editor*.ts(x)` (papel de cada arquivo em [panel.md](panel.md#editor-de-cortes)); tokens `--color-nle-*` e bloco `.nle` em `panel/src/app/globals.css` | [panel.md](panel.md#editor-de-cortes) | | Página do editor `/clipper/edit/[clipId]` | `panel/src/app/clipper/edit/[clipId]/page.tsx` + `panel/src/components/clip-editor*.ts(x)` (papel de cada arquivo em [panel.md](panel.md#editor-de-cortes)); tokens `--color-nle-*` e bloco `.nle` em `panel/src/app/globals.css` | [panel.md](panel.md#editor-de-cortes) |
| Ponte e proxy do painel | `panel/src/lib/clipper.ts` + `panel/src/app/api/clipper/[...path]/route.ts` | — | | Ponte e proxy do painel | `panel/src/lib/clipper.ts` + `panel/src/app/api/clipper/[...path]/route.ts` | — |
| Fontes (canais de live) nos canais de publicação | `linkChannel`/`endChannel`/`accountsForChannel` em `panel/src/lib/accounts.ts`; rotas `panel/src/app/api/accounts/[id]/channels/`; card "Fontes de corte" em `account-manager.tsx`. Na UI "Canais" virou **"Fontes"**; código e rotas seguem `channels` | [panel.md](panel.md) | | Fontes (canais de live) nos canais de publicação | `linkChannel`/`endChannel`/`accountsForChannel` em `panel/src/lib/accounts.ts`; rotas `panel/src/app/api/accounts/[id]/channels/`; card "Fontes de corte" em `account-manager.tsx`. Na UI "Canais" virou **"Fontes"**; código e rotas seguem `channels` | [panel.md](panel.md) |
@@ -64,10 +65,17 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
- **Aprendizado dos emotes:** aprovar/rejeitar no painel = ±0,3/0,15 nos emotes de −10 s a +6 s do pico, uma vez por - **Aprendizado dos emotes:** aprovar/rejeitar no painel = ±0,3/0,15 nos emotes de −10 s a +6 s do pico, uma vez por
corte (`clips.learned`); a decisão da IA conta com `factor=0.5`. Peso limitado a −1…3. corte (`clips.learned`); a decisão da IA conta com `factor=0.5`. Peso limitado a −1…3.
## Juízes (decisão do usuário: pela CLI, sem chave de API) ## Juízes (decisão do usuário: pela CLI; chave de API só pelo cofre do painel)
- Provedores `codex` (padrão `gpt-6-luna`; lista de `~/.codex/models_cache.json`), `claude` (`haiku`/`sonnet`/`opus`) - Provedores `codex` (padrão `gpt-6-luna`; lista de `~/.codex/models_cache.json`), `claude` (`haiku`/`sonnet`/`opus`),
ou `off` (só a heurística). `gemini` (`Judge._gemini`: `gemini -p <instrução curta> -o json --approval-mode plan --skip-trust -m <modelo>`, prompt
completo pelo stdin, schema no prompt e JSON extraído de `response`; frames copiados para pasta temporária **fora do
repo**, porque `@arquivo` respeita o `.gitignore`) ou `off` (só a heurística).
- **IA reserva por chamada** (18/11/2026): `clipper/app/ai_settings.py` lê `data/ai/settings.json` e o cofre
`data/ai/vault.bin` (DPAPI por `ctypes`; **só leitura**, quem escreve é o painel). Falha de indisponibilidade (cota,
429, login, chave, rede, CLI fora) pausa a IA e a mesma chamada segue na próxima pronta da `order`; erro de conteúdo
não troca. Contrato: `doc/ia.md`; visão geral e armadilhas: [ai.md](ai.md). Teste: `clipper/tests/test_ai_fallback.py`.
Só vale depois de reiniciar o Clipador (gotchas, item 144). Gemini com chave real e `@arquivo` de imagem: não testados.
- **ANALISTA** vê 6 frames (8 se o trecho passa de 80 s) + fala + chat + glossário e devolve `situation`, `what_happened`, `screen`, `speech`, - **ANALISTA** vê 6 frames (8 se o trecho passa de 80 s) + fala + chat + glossário e devolve `situation`, `what_happened`, `screen`, `speech`,
`chat_meaning`, `confidence` (0–1) e início/fim da ação. **EDITOR** vê só texto + a análise e escreve título, `chat_meaning`, `confidence` (0–1) e início/fim da ação. **EDITOR** vê só texto + a análise e escreve título,
legenda, nota e corte. Os dois podem recuar até `duration.backtrackS` (padrão 120 s) antes do candidato. legenda, nota e corte. Os dois podem recuar até `duration.backtrackS` (padrão 120 s) antes do candidato.
@@ -77,7 +85,7 @@ renderiza cortes verticais (1080×1920, padrão) ou horizontais (1920×1080, You
- Custo fixo: cada chamada é um processo novo (2 por candidato). `codex_lean_overrides(search, config_file=None)` em - Custo fixo: cada chamada é um processo novo (2 por candidato). `codex_lean_overrides(search, config_file=None)` em
`judge.py` enxuga o Codex; o Claude leva `--setting-sources project,local`. Números e limites em `judge.py` enxuga o Codex; o Claude leva `--setting-sources project,local`. Números e limites em
[token-economy.md](token-economy.md); teste: `test_codex_lean_overrides`. Vale após reiniciar o Clipador (gotcha 136). [token-economy.md](token-economy.md); teste: `test_codex_lean_overrides`. Vale após reiniciar o Clipador (gotcha 136).
- Não adicione chave de API ao juiz sem pedido do usuário. Corte manual é renderizado mesmo com nota baixa. - Chave de API do juiz vem só do cofre do painel (`authMode: "apiKey"`, variável só na chamada); não crie outro caminho de chave sem pedido do usuário. Corte manual é renderizado mesmo com nota baixa.
## Hashtags da legenda (`hashtags.py`) ## Hashtags da legenda (`hashtags.py`)
@@ -322,18 +330,59 @@ Teste local do editor sem tocar no serviço do usuário: instância na faixa 450
banco, com as regras do item 77 de [gotchas.md](gotchas.md). Teste de UI no painel do usuário sobre um corte real: banco, com as regras do item 77 de [gotchas.md](gotchas.md). Teste de UI no painel do usuário sobre um corte real:
intercepte as escritas (item 86) e ache as camadas do canvas pelo cursor (item 85). intercepte as escritas (item 86) e ache as camadas do canvas pelo cursor (item 85).
## Parar é parar e idioma (18/11/2026)
Texto completo no README do Clipador ("Parar é parar", "Idioma por fonte e por sessão").
- **Parar à mão pausa o monitor da fonte.** `POST /v1/sessions/{id}/stop` (corpo opcional `{"pauseMonitor": false}`;
padrão `true`) grava `channels.monitor_paused_at` + `monitor_paused_session`; o monitor pula a fonte pausada. Limpam a
pausa: `PATCH /v1/channels/{id}` com `{"monitor": true}`, `POST /v1/sessions` (gravar pelo link) e `resume` pelo painel.
Queda de live (captura cai sozinha) **não** passa pela pausa: continua `keep_live`, na mesma sessão. Na UI: a fonte
mostra "monitor pausado · você parou a sessão #N" com **Religar**; o diálogo de parar tem a opção de voltar a gravar
sozinho (marcada = não pausa).
- **Idioma.** `language` em `channels` e `sessions` (`pt-BR`, `en-US`, `es-419`; `''` = `CLIPPER_LANGUAGE`), aceito em
`POST/PATCH /v1/channels` e `POST /v1/sessions`; as visões de fonte, sessão e corte devolvem o idioma **já resolvido**.
O Whisper usa o idioma da sessão; fora de pt-BR os prompts do editor e da varredura recebem a nota de idioma de saída.
No painel, `accounts.language` (migração v9 do painel, padrão `pt-BR`) e o aviso no diálogo Publicar quando o idioma do
canal difere do idioma do corte. Versões traduzidas de um mesmo corte: **ainda não existem** (próxima etapa).
- Sem reiniciar o Clipador as rotas novas não valem; o painel trata `language`/pausa como opcionais e não quebra
(gotchas, item 166).
## Perfil do jogo (aba Jogos) ## Perfil do jogo (aba Jogos)
Toda rota abaixo devolve a lista inteira (mesma forma de `GET /v1/games`). Fonte do contrato: `doc/clipador/JOGOS.md`; seção "Contexto do jogo" de `clipper/README.md`. Toda rota abaixo devolve a
lista inteira (mesma forma de `GET /v1/games`), exceto onde dito.
**Dois idiomas.** `profile` = português (o que o painel mostra); `profileAi` = inglês (vai nos prompts; `null` = não
traduzido, a IA usa `profile`); `aiLanguage` `en-US`; `translatedAt`; `aliases` (união dos dois perfis). Campos novos do
perfil: `aliases` (≤ 10), `missions` `[{name, chapter, summary, completion_triggers ≤ 8 de 200 caracteres}]` (até 120;
`[]` quando não há lista pública — a IA nunca inventa) e `end_triggers` (≤ 12, sinais gerais de fim de missão).
`game_context` (`judge.mission_lines`: `MISSIONS_IN_PROMPT` 25, `MISSIONS_PROMPT_CHARS` 1500) manda terminar o corte de
missão logo depois do gatilho de fim. Busca por nome casa `id` **ou** alias (categoria "Grand Theft Auto VI" e tela
"GTA 6" = mesmo jogo).
| Rota | Faz | | Rota | Faz |
|---|---| |---|---|
| `GET /v1/games` | perfis com `status`, `model`, `researchedAt`, `editedAt`, `notes` (`[{text, at, section?}]`) e `profile` | | `GET /v1/games` | perfis com `status`, `error`, `model`, `researchedAt`, `editedAt`, `translatedAt`, `notes` (`[{text, at, section?}]`), `aliases`, `profile`, `profileAi` |
| `POST /v1/games/{id}/research` | refaz o perfil do zero pela web (`RESEARCH_TIMEOUT_S` 420); os pedidos guardados entram no prompt | | `POST /v1/games` `{name, notes?}` | cadastra (201, `{games, id}`, status `pending`) e pesquisa em segundo plano; 409 se o `id` ou um alias já existe |
| `PUT /v1/games/{id}` | grava o perfil editado à mão: `name`, `summary`, `genre`, `mechanics`, `clip_worthy`, `avoid`, `jargon`, `news`, `hashtags`, `sources` | | `DELETE /v1/games/{id}` | apaga o jogo (sessões não mudam; volta a ser pesquisado se o jogo reaparecer); 404 se não existe |
| `POST /v1/games/{id}/refine` | `{instruction, search, section, history}` → `{games, reply}`. `instruction` 3–1500 caracteres; `search` padrão `true` (`false` = sem web, `TIMEOUT_S` 240); `section` `""` \| `summary` \| `clip_worthy` \| `avoid` \| `mechanics` \| `news` \| `jargon` \| `hashtags` \| `sources` (`Literal` em `GameRefineIn` de `main.py`, inválido dá 422); `history` `[{role: "user"\|"ai", text ≤1500}]`, máx. 20. A IA devolve o perfil inteiro + `reply` (1–2 frases do que mudou); guarda o pedido (com `section`) e marca `edited_at` | | `POST /v1/games/{id}/research` | refaz o perfil do zero pela web **em inglês** e traduz para português (`RESEARCH_TIMEOUT_S` 420); os pedidos guardados entram no prompt |
| `POST /v1/games/{id}/translate` | gera o inglês a partir do português (jogo de antes dos perfis bilíngues) |
| `PUT /v1/games/{id}?lang=pt\|en` | grava a edição à mão no idioma `lang` (padrão `pt`) e traduz para o outro; sem IA, grava e deixa o outro desatualizado. Campos: `name`, `summary`, `genre`, `mechanics`, `clip_worthy`, `avoid`, `jargon`, `news`, `hashtags`, `sources`, `aliases`, `missions`, `end_triggers` |
| `POST /v1/games/{id}/refine` | `{instruction, search, section, history}` → `{games, reply}`. Aplica no inglês e responde em português. `instruction` 3–1500 caracteres; `search` padrão `true` (`false` = sem web, `TIMEOUT_S` 240); `section` `""` \| `summary` \| `clip_worthy` \| `avoid` \| `mechanics` \| `news` \| `jargon` \| `hashtags` \| `sources` \| `missions` \| `end_triggers` \| `aliases` (`Literal` em `GameRefineIn` de `main.py`, inválido dá 422); `history` `[{role: "user"\|"ai", text ≤1500}]`, máx. 20. A IA devolve o perfil inteiro + `reply`; guarda o pedido (com `section`) e marca `edited_at` |
| `DELETE /v1/games/{id}/notes/{index}` | esquece um pedido guardado (o perfil atual fica como está) | | `DELETE /v1/games/{id}/notes/{index}` | esquece um pedido guardado (o perfil atual fica como está) |
- Tradução que falha (ou IA desligada): a outra versão fica como estava (na pesquisa, as duas em inglês), `error`
explica e `translatedAt` não muda. Tradução nunca mexe em nome, hashtags, fontes e outros nomes, e é recusada se
perder missões.
- **Sementes:** `clipper/app/seeds/games/*.json` (`{name, aliases, researchedAt, sources, profileAi, profile}`) é
importado na subida **só se o jogo não existe**. Hoje: `gta-vi.json` (GTA VI lança 19/11/2026, sem lista oficial de
missões; a semente traz 4 do vídeo "An Extended Look" com nomes descritivos **não oficiais** — pesquisar de novo
depois do lançamento; gotchas, item 167).
- Proxy do painel (`panel/src/lib/clipper.ts`): `ALLOWED` aceita `games/<id>/(research|refine|translate|notes/n)`;
`METHODS` dá GET/POST a `games` e PUT/DELETE a `games/<id>`; timeouts: 8 min `research|refine`, 5 min `translate` e
`PUT`, 30 s `POST games`.
- `clean_profile` (`intel.py`) normaliza tudo que entra: apara, tira vazios e duplicados, no máximo 20 itens por lista. - `clean_profile` (`intel.py`) normaliza tudo que entra: apara, tira vazios e duplicados, no máximo 20 itens por lista.
São guardados os últimos 30 pedidos. São guardados os últimos 30 pedidos.
- **Pedido guardado sobrevive a "Pesquisar de novo"** (`research_game(name, title, notes)`; `PROFILE_SYSTEM` manda - **Pedido guardado sobrevive a "Pesquisar de novo"** (`research_game(name, title, notes)`; `PROFILE_SYSTEM` manda
@@ -344,13 +393,10 @@ Toda rota abaixo devolve a lista inteira (mesma forma de `GET /v1/games`).
`history`, 400 caracteres cada. `REFINE_SYSTEM` manda mexer só na seção em foco e transformar pedido genérico `history`, 400 caracteres cada. `REFINE_SYSTEM` manda mexer só na seção em foco e transformar pedido genérico
em item concreto ("reação do streamer conta" → "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga"). em item concreto ("reação do streamer conta" → "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga").
`Intel.refine(...)` (`intel.py`) devolve `(profile, reply)`. `Intel.refine(...)` (`intel.py`) devolve `(profile, reply)`.
- Painel (`clipper-games.tsx`): o cabeçalho tem selo de iniciais e os botões "Conversar com a IA" (perfil inteiro), - Painel: lista em `/clipper/games` e modal por `?game=ID` (`clipper-game-dialog.tsx`, `clipper-game-parts.tsx`); o chat
"Editar" (uma linha por item) e "Pesquisar de novo". Cada seção é um cartão com "Pedir à IA", que abre o chat `AiChat` tem a chave "Confirmar na web" **desligada** por padrão, embora a API use `search=true`. A conversa só existe
daquela seção (`AiChat`: Enter envia, Shift+Enter quebra linha, chave "Confirmar na web" **desligada** por enquanto o chat está aberto; o que fica salvo é o pedido (aba "Pedidos à IA", com X). Tipos `Game`, `GameProfile`,
padrão no painel, embora a API use `search=true` por padrão). Item recém-acrescentado aparece com selo "novo". `GameMission` em `panel/src/components/clipper-client.ts`. Detalhes visuais em [panel.md](panel.md).
"Memória da IA" lista os pedidos guardados (com a seção) e tem X. A conversa só existe enquanto o chat está
aberto. O que fica salvo é o pedido. Tipo `Game` em `panel/src/components/clipper-client.ts`
(`editedAt?`, `notes?[].section?`). Detalhes visuais em [panel.md](panel.md).
## Regras ## Regras
@@ -371,6 +417,17 @@ Toda rota abaixo devolve a lista inteira (mesma forma de `GET /v1/games`).
## Testes e evidência ## Testes e evidência
Perfis de jogo bilíngues, missões, cadastro e semente do GTA VI (18/11/2026): `pnpm test:clipper` → **335 passed**
(reexecutado nesta manutenção, 108 s; bate com o informado); 10 testes em `clipper/tests/test_game_profiles.py`. Não
verificado: IA real na pesquisa, tradução e refino bilíngues; modal e lista no navegador; serviço real em v12 (precisa
reiniciar); `pnpm typecheck` e testes do painel.
IA reserva e Gemini no juiz (18/11/2026): `pnpm test:clipper` → **335 passed** (reexecutado pela skill; `test_ai_fallback.py` novo).
Reformulação da interface e regras de pausa/idioma (18/11/2026): `pnpm test:clipper` → **287 passed** (reexecutado
nesta manutenção; 9 testes novos em `clipper/tests/test_monitor_pause_and_language.py`). Não verificado: as páginas no
navegador e o banco real em v11 (o serviço precisa reiniciar).
Os testes não chamam a CLI de IA: `FakeJudge.ask` (`clipper/tests/test_sources_and_api.py`) sempre falha, e o serviço Os testes não chamam a CLI de IA: `FakeJudge.ask` (`clipper/tests/test_sources_and_api.py`) sempre falha, e o serviço
segue pelo caminho de "IA fora". Juiz falso novo precisa cobrir `ask` também. segue pelo caminho de "IA fora". Juiz falso novo precisa cobrir `ask` também.
@@ -485,7 +542,7 @@ Não verificado:
contra o serviço reiniciado; contra o serviço reiniciado;
- apagar: rota no serviço real do usuário; arquivo em uso no Windows (deve voltar em `left`); pedido do editor em - apagar: rota no serviço real do usuário; arquivo em uso no Windows (deve voltar em `left`); pedido do editor em
andamento gravando em `edit-<id>/` depois de apagar; relógio da sessão com movimento reduzido, aba escondida e andamento gravando em `edit-<id>/` depois de apagar; relógio da sessão com movimento reduzido, aba escondida e
larguras de 1024/1280; a faixa do topo em `clipper-studio.tsx` ainda mostra o `durationS` real (sem o relógio); larguras de 1024/1280; a faixa do topo (hoje `clipper-shell.tsx`) pode ainda mostrar o `durationS` real (sem o relógio);
- duração, gancho, reenquadramento, camadas e captura: live 2K real e HEVC real da Twitch pela captura; gravação longa - duração, gancho, reenquadramento, camadas e captura: live 2K real e HEVC real da Twitch pela captura; gravação longa
em 1080p ou 2K com o serviço real; juiz e varredura reais com as durações novas; render real de um projeto feito no em 1080p ou 2K com o serviço real; juiz e varredura reais com as durações novas; render real de um projeto feito no
editor com reenquadramento e camadas comparado com a prévia (pendente, depois do reinício do serviço); camadas na editor com reenquadramento e camadas comparado com a prévia (pendente, depois do reinício do serviço); camadas na
+53 -2
View File
@@ -3,7 +3,7 @@
Cada item: **sintoma → causa → correção → onde está tratado**. Observadas na implementação da Cada item: **sintoma → causa → correção → onde está tratado**. Observadas na implementação da
prova de conceito com Godot 4.7.2 / FFmpeg 7.1.1 / pnpm 11.22 (16/11/2026). Registro formal em prova de conceito com Godot 4.7.2 / FFmpeg 7.1.1 / pnpm 11.22 (16/11/2026). Registro formal em
`doc/TEST_RESULT.md`: itens 1–5, 7, 13–15, 17 e 18; itens 30–33 estão em `voice/README.md` `doc/TEST_RESULT.md`: itens 1–5, 7, 13–15, 17 e 18; itens 30–33 estão em `voice/README.md`
("GPU e CPU"); itens 57–61 estão em `clipper/README.md` ("Armadilhas já resolvidas"); itens 74–76, 87–90 e 103–108 também estão lá e o 78 na seção "Limitações" do editor; itens 79, 81–84 e 92–95 estão em `doc/FACE_BAKEOFF.md` (o 93 também em "Variáveis" de `clipper/README.md`) (o 80, no comentário de `clipper/requirements.txt`); itens 118–128 (publicação) seguem `doc/publicacao/` e o código; itens 151–154 foram informados em 17/11/2026 (parte conferida no código); itens 129–132 foram informados em 17/11/2026 e conferidos no código (`doc_main.gd`, `doc/godot/cenas.md`) e no banco (`agent_runs` 5, 7 e 8); itens 62–67, 77, 85–86, 91, 99–102, 109–112 e as ampliações do 52, do 44, 77, 86 e 87 foram informados em 16–17/11/2026 (não estão em `doc/TEST_RESULT.md`); os demais vieram de erros de compilação ou instalação durante a implementação. ("GPU e CPU"); itens 57–61 estão em `clipper/README.md` ("Armadilhas já resolvidas"); itens 74–76, 87–90 e 103–108 também estão lá e o 78 na seção "Limitações" do editor; itens 79, 81–84 e 92–95 estão em `doc/FACE_BAKEOFF.md` (o 93 também em "Variáveis" de `clipper/README.md`) (o 80, no comentário de `clipper/requirements.txt`); itens 168–172 (IA) seguem `doc/ia.md`; itens 118–128 (publicação) seguem `doc/publicacao/` e o código; itens 151–154 foram informados em 17/11/2026 (parte conferida no código); itens 129–132 foram informados em 17/11/2026 e conferidos no código (`doc_main.gd`, `doc/godot/cenas.md`) e no banco (`agent_runs` 5, 7 e 8); itens 62–67, 77, 85–86, 91, 99–102, 109–112 e as ampliações do 52, do 44, 77, 86 e 87 foram informados em 16–17/11/2026 (não estão em `doc/TEST_RESULT.md`); os demais vieram de erros de compilação ou instalação durante a implementação.
Ao descobrir uma nova, registre aqui via `cenaforge-skill-updater`. Os números são estáveis Ao descobrir uma nova, registre aqui via `cenaforge-skill-updater`. Os números são estáveis
(outros textos os citam): item novo entra na seção do assunto com o próximo número livre. (outros textos os citam): item novo entra na seção do assunto com o próximo número livre.
@@ -756,6 +756,57 @@ observada num envio real ainda. Contexto em [publishing.md](publishing.md).
162. **Regex com `\b` escrita por heredoc/Python sem string raw vira um caractere de controle (backspace, 0x08)** (aconteceu 2x ao 162. **Regex com `\b` escrita por heredoc/Python sem string raw vira um caractere de controle (backspace, 0x08)** (aconteceu 2x ao
editar `montage-cartoon.ts`): a regex deixa de casar, sem erro. Use `r"..."` ou o Edit (item 44) e confira com editar `montage-cartoon.ts`): a regex deixa de casar, sem erro. Use `r"..."` ou o Edit (item 44) e confira com
`grep -nP "\x08" <arquivo>` que não sobrou nenhum. `grep -nP "\x08" <arquivo>` que não sobrou nenhum.
163. **Cartoon: a boca (curva quadrática) só chega à METADE do ponto de controle.** Controles da boca ficam no dobro da
abertura desejada. Onde: `cartoon/src/CharacterFigure.tsx`.
164. **Script de teste em Python que grava JSON com `open(..., "w")` sem `encoding` estraga acento no Windows** (cp1252; o
render lê UTF-8). Sempre `open(..., "w", encoding="utf-8")` (e `ensure_ascii=False` se quiser acento legível). Mesma
família do item 153. Onde: ao gerar `character.json`/spec por script.
165. **Cartoon: sombra do corpo/barriga em elipse parece mancha.** Correção: elipse + curva de volume (contorno) e sombra
lateral recortada por `clipPath`. Onde: `cartoon/src/CharacterFigure.tsx`.
166. **Clipador: depois de parar a sessão à mão, a fonte não grava de novo (ou as rotas/campos novos "não pegam").**
Dois lados. (a) Parar à mão pausa o monitor da fonte de propósito (`monitor_paused_at`): live no ar e nada
reabrindo não é falha. Religar = "Religar" em `/clipper/sources`, `PATCH /v1/channels/{id}` `{"monitor": true}`,
gravar pelo link ou retomar a sessão; `{"pauseMonitor": false}` no stop evita a pausa. Queda de live sem ninguém
parar continua retomando na mesma sessão. (b) Serviço sem `--reload` (item 144): sem reiniciar, `stop` não pausa,
`language` não é aceito nem devolvido e a migração v11 não roda; o painel trata os campos como opcionais, então
nada quebra, só não pega. Reinicie (é do usuário) e confira `PRAGMA user_version` = 11. Onde:
`clipper/app/worker.py`, `main.py` (`StopIn`), `db.py` (v11); teste `clipper/tests/test_monitor_pause_and_language.py`.
167. **Clipador: perfil do jogo sem versão em inglês, GTA VI ausente ou "cadastrar jogo" que não funciona.** (a) Serviço
sem reiniciar (item 144): a migração v12 não roda, `POST /v1/games`, `translate`, `DELETE` e `?lang=` não existem e a
semente do GTA VI não é importada (só entra na subida, e só se o jogo não existe: nunca sobrescreve edição).
Reinicie (é do usuário) e confira `PRAGMA user_version` = 12. (b) Jogo antigo tem `profileAi: null`: a IA usa o
português até rodar `POST /v1/games/{id}/translate` ("Gerar versão em inglês" no modal). (c) Categoria ou tela com
outro nome ("Grand Theft Auto VI" × "GTA 6") só cai no mesmo perfil se o nome estiver em `aliases`; cadastro com nome
já existente (inclusive alias) dá 409. (d) Missões só entram quando a lista é pública; **a semente do GTA VI traz 4
missões do vídeo "An Extended Look" com nomes descritivos, não oficiais** (jogo lança 19/11/2026, sem lista oficial):
pesquisar de novo depois do lançamento, sem apagar o jogo. Edição à mão em um idioma é traduzida para o outro; tradução
que falha deixa a outra versão como estava e `error` explica. Onde: `clipper/app/intel.py` (`import_seeds`,
`add_game`, `translate`), `main.py`, `db.py` (v12), `seeds/games/`; teste `clipper/tests/test_game_profiles.py`.
## IA: provedores, login e reserva
Itens 168–172 informados em 18/11/2026 e conferidos contra `doc/ia.md` e o código. Contexto em [ai.md](ai.md).
168. **Gemini CLI com login Google: `IneligibleTierError: UNSUPPORTED_CLIENT`** (gemini-cli 0.68.0). Causa: o OAuth gratuito
"Code Assist for individuals" foi encerrado; o Google manda migrar para o Antigravity. OAuth só com plano elegível
(Code Assist Standard/Enterprise, Workspace). Correção: conta pessoal usa **chave do AI Studio** (`authMode: "apiKey"`).
O erro conta como indisponibilidade (`IneligibleTier`) e aciona a reserva. Onde: `panel/src/lib/ai.ts`, `doc/ia.md`.
169. **`CODEX_API_KEY` só vale no `codex exec`** (confirmado no binário 0.169.0). Para chave sem mexer na conta do usuário,
ponha a variável só na chamada (`providerEnv`); **não** use `codex login --with-api-key`, que troca o login global.
Mesma regra para `ANTHROPIC_API_KEY` e `GEMINI_API_KEY`. Onde: `providerEnv` em `panel/src/lib/ai.ts`.
170. **Terminal de login no Windows: aspas do `cmd` e caminho com espaço ("Program Files").** Forma que funcionou:
`cmd /d /c start "<título>" cmd.exe /k "<linha>"` com `windowsVerbatimArguments: true` (testado com caminho em
"Program Files"); sem o modo verbatim o Node reescreve as aspas (causa não isolada). Onde: `openLoginTerminal` em
`panel/src/lib/ai.ts`.
171. **Status das IAs lento (~0,3 s por chamada ao cofre).** Causa: a DPAPI no Node passa por PowerShell. Correção: cofre
em cache por `mtime` de `data/ai/vault.bin`; o Clipador lê com `ctypes` (`clipper/app/ai_settings.py`). Não leia o
cofre por requisição sem o cache.
172. **CLI instalada "não aparece" no painel.** Causa: o PATH do painel é o de quando ele abriu (instalação nova não entra),
e o instalador nativo do Claude usa `~/.local/bin` e o npm `%APPDATA%\npm`. Correção: `resolveCommand` procura nesses
dois lugares além do PATH; mesmo assim, instalar e não ver = "Verificar" de novo na tela. Gemini no Windows: o
`gemini.cmd` exige shell, então roda `node …/@google/gemini-cli/bundle/gemini.js` (mesma família do item 28).
Relacionadas, já registradas acima: Relacionadas, já registradas acima:
- Patch por script em arquivos CRLF do painel (`lib/metrics.ts`, `components/metrics-view.tsx`, `dashboard-controls.tsx`, - Patch por script em arquivos CRLF do painel (`lib/metrics.ts`, `components/metrics-view.tsx`, `dashboard-controls.tsx`,
@@ -763,4 +814,4 @@ Relacionadas, já registradas acima:
- `codex.cmd` sem shell: item 28. - `codex.cmd` sem shell: item 28.
- Script de patch com regex (`\b`) passado por heredoc: item 44. - Script de patch com regex (`\b`) passado por heredoc: item 44.
- Publicador roda sem `--reload`: mudança em `publisher/app/` só vale depois de reiniciar o `pnpm dev` (itens 137, 139, 140, 142, 143, 145 e 147; o Clipador também: 144). - Publicador roda sem `--reload`: mudança em `publisher/app/` só vale depois de reiniciar o `pnpm dev` (itens 137, 139, 140, 142, 143, 145 e 147; o Clipador também: 144).
- Migração do painel (v3 … v8) é aplicada na 1ª requisição depois da recarga do `db.ts`; reiniciar o `pnpm panel`/`pnpm dev` só se isso não bastar: itens 51 e 138 (reiniciar mata agente em execução: item 131). - Migração do painel (v3 … v10) é aplicada na 1ª requisição depois da recarga do `db.ts`; reiniciar o `pnpm panel`/`pnpm dev` só se isso não bastar: itens 51 e 138 (reiniciar mata agente em execução: item 131).
+45 -12
View File
@@ -19,13 +19,15 @@ Fonte: código em `panel/src/lib/` e `panel/README.md`. O painel é do usuário:
(ex.: `CutSettingsDialog` de `clipper-cut-settings.tsx`). Não monte um segundo host. (ex.: `CutSettingsDialog` de `clipper-cut-settings.tsx`). Não monte um segundo host.
- `Button` (`components/ui.tsx`) tipa as props como `ComponentProps<"button">` e aceita `ref` (React 19). - `Button` (`components/ui.tsx`) tipa as props como `ComponentProps<"button">` e aceita `ref` (React 19).
## Banco (`data/cenaforge.db`, esquema v7) ## Banco (`data/cenaforge.db`, esquema v10)
- Migração em `panel/src/lib/db.ts` (lista `MIGRATIONS`). Banco com dados → cópia em `data/backups/` - Migração em `panel/src/lib/db.ts` (lista `MIGRATIONS`). Banco com dados → cópia em `data/backups/`
antes de migrar (`cenaforge-v<atual>-<data>.db`). `foreign_keys = OFF` fora da transação e `PRAGMA antes de migrar (`cenaforge-v<atual>-<data>.db`). `foreign_keys = OFF` fora da transação e `PRAGMA
foreign_key_check` antes do `COMMIT` de cada versão. foreign_key_check` antes do `COMMIT` de cada versão.
- v3: `account_channels` (conta ↔ canal de live do Clipador; `status` `active`/`ended`). O canal - v3: `account_channels` (conta ↔ canal de live do Clipador; `status` `active`/`ended`). O canal
vive em `data/clipper/clipper.db`, então não há chave estrangeira para ele. vive em `data/clipper/clipper.db`, então não há chave estrangeira para ele.
- v9: `accounts.language` (idioma e público do canal de publicação; padrão `pt-BR`; opções em `ACCOUNT_LANGUAGES` de
`panel/src/lib/languages.ts`). A v8 (última leitura dos números das redes) não está descrita aqui: ver publishing.md.
- v4: reconstrói `stories` (SQLite não altera CHECK) para `kind` aceitar `'documentary'`; mesmas - v4: reconstrói `stories` (SQLite não altera CHECK) para `kind` aceitar `'documentary'`; mesmas
colunas e ids. colunas e ids.
- v5: publicação real — `publish_jobs`, `app_settings`, `clip_auto_approvals`; `account_networks` e `publications` - v5: publicação real — `publish_jobs`, `app_settings`, `clip_auto_approvals`; `account_networks` e `publications`
@@ -35,6 +37,7 @@ Fonte: código em `panel/src/lib/` e `panel/README.md`. O painel é do usuário:
- v6: reconstrói `publish_jobs` (ids preservados) com `schedule_source` (`auto`/`manual`/`now`) e `cancel_reason` - v6: reconstrói `publish_jobs` (ids preservados) com `schedule_source` (`auto`/`manual`/`now`) e `cancel_reason`
`unlinked`. Banco real em v6 (`PRAGMA user_version`, conferido em 17/11/2026, antes da v7). `unlinked`. Banco real em v6 (`PRAGMA user_version`, conferido em 17/11/2026, antes da v7).
- v7: `publish_jobs.origin` (`link`/`manual`, padrão `link`): job criado pelo botão "Publicar" do corte. Ver publishing.md. - v7: `publish_jobs.origin` (`link`/`manual`, padrão `link`): job criado pelo botão "Publicar" do corte. Ver publishing.md.
- v10: `agent_runs.fallback_of` (execução que continuou outra que caiu por indisponibilidade; IA reserva — [ai.md](ai.md)).
- API: toda rota `/api/**` passa por `panel/src/proxy.ts` (Host local; escrita exige `Origin` do painel) e corpo por - API: toda rota `/api/**` passa por `panel/src/proxy.ts` (Host local; escrita exige `Origin` do painel) e corpo por
`readJson` (415 sem `Content-Type: application/json`) — gotchas, item 125. `readJson` (415 sem `Content-Type: application/json`) — gotchas, item 125.
- A conexão fica em `globalThis.__cenaforgeDb`; a marca de módulo `checkedThisModule` faz a 1ª chamada de `db()` depois - A conexão fica em `globalThis.__cenaforgeDb`; a marca de módulo `checkedThisModule` faz a 1ª chamada de `db()` depois
@@ -248,7 +251,13 @@ Cada trecho vira um MP4 de desenho 2D montado por peças a partir do texto; pers
informando o formato (o subagente é uma casca que lê `doc/roteiro/`; sem WebSearch, fato sem fonte fica informando o formato (o subagente é uma casca que lê `doc/roteiro/`; sem WebSearch, fato sem fonte fica
"a confirmar"); no **Codex** manda ler os guias e escrever sozinho, sem usar `.claude/agents/` (mesma "a confirmar"); no **Codex** manda ler os guias e escrever sozinho, sem usar `.claude/agents/` (mesma
regra no `AGENTS.md`). regra no `AGENTS.md`).
- Lista de modelos = `models()` (não há mais constante fixa): - **Três provedores** (`claude`, `codex`, `gemini`), configurados em **Configurações → IA** (`/settings/ai`: ligar/desligar,
conta ou chave de API, ordem da reserva, instalar, entrar, testar). **IA reserva:** agente que termina com erro de
indisponibilidade é pausado e a mesma tarefa recomeça na próxima IA pronta (`agent_runs.fallback_of`; o console segue
o `followUpRunId` também nesse caso; vertentes religadas à nova execução). Contrato, API e armadilhas em
[ai.md](ai.md). Configurações são subpáginas `/settings/{ai,publishing,apps,browser,modes}` (`/settings` → IA;
`SETTINGS_SECTIONS` em `settings-shell.tsx`, também no menu lateral); link antigo `/settings?tab=apps` não existe mais.
- Lista de modelos = `models()` (não há mais constante fixa; o Gemini usa `geminiModels()` de `lib/ai.ts`):
- Codex: lê `models_cache.json` de `$CODEX_HOME` (padrão `~/.codex`), que a CLI do Codex atualiza - Codex: lê `models_cache.json` de `$CODEX_HOME` (padrão `~/.codex`), que a CLI do Codex atualiza
sozinha; filtra `visibility === "list"`, ordena por `priority`. Primeira opção "Padrão da CLI (…)" sozinha; filtra `visibility === "list"`, ordena por `priority`. Primeira opção "Padrão da CLI (…)"
= `model = "..."` do `config.toml`. O id vai em `codex exec -m <slug>`. Em 17/11/2026: 8 modelos = `model = "..."` do `config.toml`. O id vai em `codex exec -m <slug>`. Em 17/11/2026: 8 modelos
@@ -266,8 +275,9 @@ Cada trecho vira um MP4 de desenho 2D montado por peças a partir do texto; pers
em `createStoryFromTextAction`, `app/actions.ts`). Por script: `POST /api/stories {text, title?, kind?, provider?, em `createStoryFromTextAction`, `app/actions.ts`). Por script: `POST /api/stories {text, title?, kind?, provider?,
model?}` (`app/api/stories/route.ts`; `kind` padrão `documentary`, texto 20–20.000 caracteres) cria a história + ep01 model?}` (`app/api/stories/route.ts`; `kind` padrão `documentary`, texto 20–20.000 caracteres) cria a história + ep01
e dispara o agente `story` → `{storyId, episodeId, runId}` (cabeçalho `Origin`: gotchas, item 125). e dispara o agente `story` → `{storyId, episodeId, runId}` (cabeçalho `Origin`: gotchas, item 125).
- O agente roda dentro do processo do painel: reiniciar o `pnpm panel` o mata (gotchas, item 131). Limite de uso do - O agente roda dentro do processo do painel: reiniciar o `pnpm panel` o mata (gotchas, item 131). Limite de uso no
Claude/Codex para a tarefa no meio: continue no outro provedor com o contexto (item 132). meio da tarefa: com a reserva ligada o painel recomeça sozinho na próxima IA (item 132 vale só com a reserva
desligada ou sem outra IA pronta: continue à mão no outro provedor com o contexto).
- Prompt do Codex manda ler texto no PowerShell com `Get-Content -Raw -Encoding UTF8` (gotchas, item 98). - Prompt do Codex manda ler texto no PowerShell com `Get-Content -Raw -Encoding UTF8` (gotchas, item 98).
### Mensagem com o agente rodando ### Mensagem com o agente rodando
@@ -336,6 +346,29 @@ Limitação: o overlay da Godot só tem `choiceA`/`choiceB` (`scene_config.gd`);
## Página `/clipper` (Clipador) ## Página `/clipper` (Clipador)
Reformulada em 18/11/2026 (`doc/clipador/REDESIGN.md`): deixou de ser uma página com 5 abas e virou **subpáginas** no
grupo de rotas `panel/src/app/clipper/(studio)/`. O `layout.tsx` monta `ClipperProvider` (`clipper-provider.tsx`: dados +
consulta periódica; `useClipper()`) e `ClipperShell` (`clipper-shell.tsx`: cabeçalho compacto com estado do serviço,
bloco "Ao vivo agora · N" com uma linha por live, sub-navegação com contadores). Sub-navegação = `CLIPPER_SECTIONS`; a
sidebar (`sidebar-nav.tsx`) mostra os mesmos subitens quando o Clipador está ativo. Seção nova = entrada em
`CLIPPER_SECTIONS` + pasta em `(studio)/`.
| Rota | Conteúdo | Arquivos |
|---|---|---|
| `/clipper` Cortes | lista `ClipTable` (uma linha por corte; ações rápidas Aprovar/Rejeitar/Publicar), filtros na URL (`?stage ?source ?session ?lang`), modal `ClipDialog` por `?clip=ID` com anterior/próximo | `clipper-clips-page.tsx`, `clipper-clip-table.tsx`, `clipper-clip-dialog.tsx`, `clipper-clip-parts.tsx`; ordenar/apagar/selecionar em utilitários de `clipper-queue.tsx` |
| `/clipper/sessions` | lista de sessões; "Gravar pelo link" em diálogo (`RecordForm`) | `clipper-sessions-page.tsx` |
| `/clipper/sessions/[id]` | saúde, resumo da IA, tiles, gráfico do chat, emotes, configuração do corte | `clipper-session-detail.tsx` |
| `/clipper/sources` | fontes em tabela, "Adicionar fonte" em diálogo, monitor ligado/**pausado** + Religar, idioma da live, canais de publicação | `clipper-channels.tsx` |
| `/clipper/games` | jogos em tabela (nome, gênero, estado, missões, última pesquisa/edição), "Adicionar jogo" em diálogo, `?game=ID` abre o modal do jogo e emotes do canal | `clipper-games-page.tsx`, `clipper-game-dialog.tsx` (modal), `clipper-game-parts.tsx` (seções, `AiChat`, editor à mão), `clipper-games.tsx` |
| `/clipper/settings` | abas Juiz (IA) / Serviço / Idiomas e públicos | `clipper-settings-page.tsx`, `clipper-judge.tsx` |
| `/clipper/edit/[clipId]` | editor em tela cheia, **fora** do grupo `(studio)` | ver "Editor de cortes" |
`clipper-studio.tsx` foi **apagado**; `clipper-queue.tsx` virou só utilitários da lista (a lista é `ClipTable`);
`clipper-sessions.tsx` virou peças compartilhadas (`PlatformIcon`, `CutNow`, `RecordForm`, relógio, `sessionHealth`).
Canal de publicação: campo "Idioma e público" em `account-manager.tsx`; aviso de idioma em `clip-publish.tsx`.
Os parágrafos abaixo descrevem o comportamento de cada peça; onde falam em "aba", "cartão" ou "fila", leia "página",
"linha" e "lista de cortes" (a reescrita deles não foi verificada no navegador).
- `clipper-cut-settings.tsx`: modal "Configuração do corte" em cinco abas — Formato e duração (com a seção - `clipper-cut-settings.tsx`: modal "Configuração do corte" em cinco abas — Formato e duração (com a seção
"Qualidade da gravação" e o disco por hora de cada opção, de `captureQualities`) · Câmera e layout · Legenda (com "Qualidade da gravação" e o disco por hora de cada opção, de `captureQualities`) · Câmera e layout · Legenda (com
seletor de fonte) · Gancho (estilo, cores, fonte, animação de entrada, "Ver a entrada") · Crédito — com a prévia ao seletor de fonte) · Gancho (estilo, cores, fonte, animação de entrada, "Ver a entrada") · Crédito — com a prévia ao
@@ -345,7 +378,7 @@ Limitação: o overlay da Godot só tem `choiceA`/`choiceB` (`scene_config.gd`);
- `clipper-client.ts`: tipo `Aspect`, `format` em `CutSettings`, `aspect?` em `Clip`, `aspectOf()` (ausente = - `clipper-client.ts`: tipo `Aspect`, `format` em `CutSettings`, `aspect?` em `Clip`, `aspectOf()` (ausente =
vertical) e `withFormat()` (completa a resposta de um serviço antigo sem `format`). Na fila (`clipper-queue.tsx`) vertical) e `withFormat()` (completa a resposta de um serviço antigo sem `format`). Na fila (`clipper-queue.tsx`)
o corte horizontal aparece em 16:9. o corte horizontal aparece em 16:9.
- Aba Sessões (`clipper-sessions.tsx`; cabeçalho em `clipper-studio.tsx`): cartão com cabeçalho (tempo gravado, - Sessão (`clipper-sessions.tsx`, `clipper-session-detail.tsx`): cartão com cabeçalho (tempo gravado,
"gravando em L×A · fps" de `capture` e ações), frase de saúde (`sessionHealth()`), painel "o que está acontecendo" (resumo da IA + jogo), quatro blocos "gravando em L×A · fps" de `capture` e ações), frase de saúde (`sessionHealth()`), painel "o que está acontecendo" (resumo da IA + jogo), quatro blocos
(Chat, Transcrição, IA assistiu, Cortes) e barra de ferramentas. **Altura fixa por desenho**: nada pode pular na (Chat, Transcrição, IA assistiu, Cortes) e barra de ferramentas. **Altura fixa por desenho**: nada pode pular na
atualização automática. "Retomar gravação" aparece em toda live que não está gravando (botão principal só em atualização automática. "Retomar gravação" aparece em toda live que não está gravando (botão principal só em
@@ -358,12 +391,12 @@ Limitação: o overlay da Godot só tem `choiceA`/`choiceB` (`scene_config.gd`);
atrasou, "gerando o próximo resumo…". O intervalo vem de `/status` → `judge.options.scanIntervalS` atrasou, "gerando o próximo resumo…". O intervalo vem de `/status` → `judge.options.scanIntervalS`
(`useScanInterval`; reserva 180 = `OPTION_DEFAULTS` de `intel.py`). Existe porque o dono achou que o resumo (`useScanInterval`; reserva 180 = `OPTION_DEFAULTS` de `intel.py`). Existe porque o dono achou que o resumo
travava (gotchas, item 115). travava (gotchas, item 115).
- `clipper-games.tsx`: aba Jogos e emotes. O card do jogo tem selo de iniciais (primeira + última palavra, cor - Jogos (`clipper-games-page.tsx` + `clipper-game-dialog.tsx` + `clipper-game-parts.tsx`; `clipper-games.tsx` guarda
por `hueOf`) e os botões "Conversar com a IA", "Editar" e "Pesquisar de novo". Cada seção é um cartão com os emotes do canal): lista em tabela; o modal tem alternância **Português (você lê) / English (vai para a IA)** e abas
barra colorida, contador e "Pedir à IA", que abre o chat inline `AiChat` (balões, atalhos de pedido por seção, Visão geral · Rende corte · Missões · Gatilhos de fim · Termos e hashtags · Fontes · Pedidos à IA, com Pesquisar de
indicador de digitação, "+N itens novos / −N removidos"). Item novo fica verde com selo "novo". Gírias viram novo, Editar, Pedir à IA (`AiChat`: atalhos por seção, "+N itens novos / −N removidos") e Apagar. Editar grava no
chips, e Fontes e "Memória da IA" ficam recolhidas. A aba também mostra os emotes do canal com usos e peso. idioma da alternância e o serviço traduz o outro. Rotas e regras em [clipper.md](clipper.md#perfil-do-jogo-aba-jogos).
Rotas e regras em [clipper.md](clipper.md#perfil-do-jogo-aba-jogos). - Sidebar: os subitens do Clipador usam os mesmos ícones das abas do topo (`sidebar-nav.tsx`, `SubItem.icon`).
- `clipper-queue.tsx`: cartão do corte mostra a análise do juiz e recua/avança o início (`START_STEPS` - `clipper-queue.tsx`: cartão do corte mostra a análise do juiz e recua/avança o início (`START_STEPS`
−30/−10/−5/−2/+2 s). `clipper-judge.tsx`: modelos do editor e do analista, varredura, visão, câmera. −30/−10/−5/−2/+2 s). `clipper-judge.tsx`: modelos do editor e do analista, varredura, visão, câmera.
- **Ordenar a fila** (`clipper-queue.tsx`, seletor "Ordenar" ao lado do filtro de sessão; `QUEUE_SORTS`, `useQueueSort`): - **Ordenar a fila** (`clipper-queue.tsx`, seletor "Ordenar" ao lado do filtro de sessão; `QUEUE_SORTS`, `useQueueSort`):
@@ -523,4 +556,4 @@ Apagar na fila, relógio da sessão e prévia igual ao render (17/11/2026): `npx
(reconferido pela skill). Informado pelo coordenador: porte da legenda em 22 conferências contra o Python; corte 61 (reconferido pela skill). Informado pelo coordenador: porte da legenda em 22 conferências contra o Python; corte 61
montado no editor e renderizado pelo serviço com enquadramento, inserção e legenda iguais à prévia em montado no editor e renderizado pelo serviço com enquadramento, inserção e legenda iguais à prévia em
2/3,5/5/6,5/8 s. Não verificado: apagar pela UI contra o serviço real; relógio com movimento reduzido, aba escondida 2/3,5/5/6,5/8 s. Não verificado: apagar pela UI contra o serviço real; relógio com movimento reduzido, aba escondida
e larguras de 1024/1280; a faixa do topo de `clipper-studio.tsx` ainda usa o `durationS` real. e larguras de 1024/1280; a faixa do topo (hoje `clipper-shell.tsx`) pode ainda usar o `durationS` real.
+5 -4
View File
@@ -21,9 +21,9 @@ prévia e registre aqui (via `cenaforge-skill-updater`).
| Next.js / React / Tailwind | 16.4.6 / 19.3.0 / 4.3.3 | painel (`panel/`) | dependências do workspace | 16/11/2026 | | Next.js / React / Tailwind | 16.4.6 / 19.3.0 / 4.3.3 | painel (`panel/`) | dependências do workspace | 16/11/2026 |
| @xyflow/react | 13.0.1 | árvore de vertentes na aba Fluxo (`panel/src/components/story-flow.tsx`) | dependência do painel | 16/11/2026 | | @xyflow/react | 13.0.1 | árvore de vertentes na aba Fluxo (`panel/src/components/story-flow.tsx`) | dependência do painel | 16/11/2026 |
| SQLite | `node:sqlite` (Node 24) | banco do painel, sem dependência nativa | embutido | 16/11/2026 | | SQLite | `node:sqlite` (Node 24) | banco do painel, sem dependência nativa | embutido | 16/11/2026 |
| Codex CLI | 0.169.0 (`@openai/codex`) | agente no painel (`codex exec --json -m <slug>`, sandbox `workspace-write`); modelos lidos de `~/.codex/models_cache.json` (panel.md, "Agentes e modelos") | `CODEX_BIN` → `.exe` no PATH → `codex.js` ao lado do `codex.cmd` do npm | 17/11/2026 | | Codex CLI | 0.169.0 (`@openai/codex`) | agente no painel (`codex exec --json -m <slug>`, sandbox `workspace-write`); modelos lidos de `~/.codex/models_cache.json` (panel.md, "Agentes e modelos") | `CODEX_BIN` → `.exe` no PATH → `codex.js` ao lado do `codex.cmd` do npm | 17/11/2026 (`--version` reconferido em 18/11/2026) |
| API do Wikimedia Commons (`commons.wikimedia.org/w/api.php`) | sem versão (HTTP público, sem chave; User-Agent genérico) | fotos reais por trecho na montagem documental (`panel/src/lib/image-search.ts`), com autor, licença e página de origem nos créditos | chamada direta do painel | 17/11/2026 (`ep01.montage.json`: 5 fotos do Commons com licença CC registrada; MP4 de 88,3 s; licença não conferida na página de cada foto) | | API do Wikimedia Commons (`commons.wikimedia.org/w/api.php`) | sem versão (HTTP público, sem chave; User-Agent genérico) | fotos reais por trecho na montagem documental (`panel/src/lib/image-search.ts`), com autor, licença e página de origem nos créditos | chamada direta do painel | 17/11/2026 (`ep01.montage.json`: 5 fotos do Commons com licença CC registrada; MP4 de 88,3 s; licença não conferida na página de cada foto) |
| Claude Code CLI | 2.1.314 | agente chamado pelo painel (`-p`, `stream-json`, `--resume`, `--model claude-*-5-5`/`claude-fable-5-2`) | `CLAUDE_BIN` → `PATH` (`claude.exe`) | 17/11/2026 | | Claude Code CLI | 2.1.314 | agente chamado pelo painel (`-p`, `stream-json`, `--resume`, `--model claude-*-5-5`/`claude-fable-5-2`) | `CLAUDE_BIN` → `PATH` (`claude.exe`) → `~/.local/bin` | 17/11/2026 (`--version` reconferido em 18/11/2026) |
Estilo Cartoon (`cartoon/`, 17/11/2026; contrato e uso em [cartoon.md](cartoon.md)): Estilo Cartoon (`cartoon/`, 17/11/2026; contrato e uso em [cartoon.md](cartoon.md)):
@@ -35,8 +35,8 @@ Estilo Cartoon (`cartoon/`, 17/11/2026; contrato e uso em [cartoon.md](cartoon.m
| Fontes Anton e Bebas Neue | `assets/fonts/` (`publicDir` = `assets`) | texto das etiquetas e legenda | ver licenças em "Clipador" | | Fontes Anton e Bebas Neue | `assets/fonts/` (`publicDir` = `assets`) | texto das etiquetas e legenda | ver licenças em "Clipador" |
Licença da Remotion: grátis para pessoa física e empresa pequena; empresa maior paga. **Conferir os termos antes de uso Licença da Remotion: grátis para pessoa física e empresa pequena; empresa maior paga. **Conferir os termos antes de uso
comercial** (não verificado aqui). Testes: `npx tsx --test tests/*.test.ts` em `cartoon/` (5 testes de `spec.test.ts`); comercial** (não verificado aqui). Testes: `npx tsx --test tests/*.test.ts` em `cartoon/` (5 de `spec.test.ts` + 11 de `motion.test.ts`);
painel: `montage-cartoon.test.ts` (9). Cartoon 5/5 reexecutado em 17/11/2026; painel 77/77 informado pelo dono. painel: `montage-cartoon.test.ts` (10). Cartoon 16/16 reexecutado em 17/11/2026; painel 78/78 informado pelo dono.
Hardware do teste de referência: i9-13900K, 64 GB, RTX 2060 SUPER. Tempos: prévia 540×960 Hardware do teste de referência: i9-13900K, 64 GB, RTX 2060 SUPER. Tempos: prévia 540×960
42–44 s; final 1080×1920 ~160 s. A etapa de render da Godot ocupa 94–96% do total, dominada 42–44 s; final 1080×1920 ~160 s. A etapa de render da Godot ocupa 94–96% do total, dominada
@@ -168,6 +168,7 @@ segurança).
| Ferramenta | Para quê | Situação | | Ferramenta | Para quê | Situação |
|---|---|---| |---|---|---|
| Gemini CLI (`@google/gemini-cli`) | terceiro provedor de IA (agentes do painel e juiz do Clipador; [ai.md](ai.md)) | **código pronto, nunca executado de verdade**: não instalado nesta máquina (18/11/2026, `gemini: command not found`); a versão 0.68.0 do contrato (`doc/ia.md`) vem de teste do dono e não foi reverificada aqui. Coberto só por testes sem CLI (`ai.test.ts`, `test_ai_fallback.py`). OAuth gratuito de conta pessoal encerrado (gotchas, item 168); uso real exige chave do AI Studio, ainda não testada. Passa a "Em uso" depois de uma tarefa real concluída por ele |
| Meshy | gerar modelos GLB (personagens, objetos) e rig | citada na especificação; não testada | | Meshy | gerar modelos GLB (personagens, objetos) e rig | citada na especificação; não testada |
| Mixamo | animações para personagens com rig | citada como não obrigatória; não testada | | Mixamo | animações para personagens com rig | citada como não obrigatória; não testada |
| `.glb` carregado por `GLTFDocument` em tempo de execução (Godot) | modelos prontos dentro de cenas da biblioteca (`library/<id>/assets/`) | **só documentado** em `doc/godot/cenas.md`; nenhum `.glb` no repositório nem render com ele (17/11/2026). Personagens e barcos atuais são procedurais (`godot/kits/`) | | `.glb` carregado por `GLTFDocument` em tempo de execução (Godot) | modelos prontos dentro de cenas da biblioteca (`library/<id>/assets/`) | **só documentado** em `doc/godot/cenas.md`; nenhum `.glb` no repositório nem render com ele (17/11/2026). Personagens e barcos atuais são procedurais (`godot/kits/`) |
+41
View File
@@ -0,0 +1,41 @@
{
"schemaVersion": 1,
"id": "cam",
"name": "Cam",
"kind": "cartoon",
"look": {
"build": "heavy",
"height": 1,
"skin": "#9a6440",
"hair": {
"style": "curly",
"color": "#3a2a1e"
},
"beard": {
"style": "stubble",
"color": "#3a2a1e"
},
"glasses": "none",
"brows": "thin",
"top": {
"style": "robe",
"color": "#56704a",
"accent": "#6b4a2a"
},
"bottom": {
"style": "pants",
"color": "#2c3346"
},
"shoes": "#6b4a2a",
"footwear": "sandals",
"nose": "round",
"lids": 0.1,
"wrinkles": 0,
"head": "wide",
"belly": true
},
"caption": "Filho de Noé",
"description": "homem de 40 anos, moreno, forte, cabelo cacheado preto, barba por fazer, túnica verde, sandália",
"createdAt": "2026-11-18T03:23:14.030Z",
"updatedAt": "2026-11-18T03:23:57.151Z"
}
@@ -0,0 +1,40 @@
{
"schemaVersion": 1,
"id": "esposa-de-noe",
"name": "Esposa de Noé",
"kind": "cartoon",
"look": {
"build": "average",
"height": 0.92,
"skin": "#d09a70",
"hair": {
"style": "long",
"color": "#c9c9cf"
},
"beard": {
"style": "none",
"color": "#a9a9b0"
},
"glasses": "none",
"brows": "thick",
"top": {
"style": "robe",
"color": "#8a6f9e",
"accent": "#6b4a2a"
},
"bottom": {
"style": "pants",
"color": "#2c3346"
},
"shoes": "#6b4a2a",
"footwear": "sandals",
"nose": "button",
"lids": 0.3,
"wrinkles": 0.7,
"head": "round"
},
"caption": "Família de Noé",
"description": "senhora idosa, mulher, cabelo longo grisalho, túnica roxa, sandália, rugas, olhar gentil",
"createdAt": "2026-11-18T03:23:13.978Z",
"updatedAt": "2026-11-18T03:23:57.084Z"
}
+40
View File
@@ -0,0 +1,40 @@
{
"schemaVersion": 1,
"id": "jafe",
"name": "Jafé",
"kind": "cartoon",
"look": {
"build": "slim",
"height": 1.08,
"skin": "#d4a074",
"hair": {
"style": "side",
"color": "#6b4226"
},
"beard": {
"style": "goatee",
"color": "#6b4226"
},
"glasses": "none",
"brows": "thin",
"top": {
"style": "robe",
"color": "#c8443a",
"accent": "#6b4a2a"
},
"bottom": {
"style": "pants",
"color": "#2c3346"
},
"shoes": "#6b4a2a",
"footwear": "sandals",
"nose": "round",
"lids": 0.1,
"wrinkles": 0,
"head": "round"
},
"caption": "Filho de Noé",
"description": "homem de 35 anos, magro, alto, cabelo repartido castanho, cavanhaque, túnica vermelha, sandália",
"createdAt": "2026-11-18T03:23:14.057Z",
"updatedAt": "2026-11-18T03:23:57.183Z"
}
+40
View File
@@ -0,0 +1,40 @@
{
"schemaVersion": 1,
"id": "noe",
"name": "Noé",
"kind": "cartoon",
"look": {
"build": "slim",
"height": 0.96,
"skin": "#c98a5e",
"hair": {
"style": "long",
"color": "#e2e2e8"
},
"beard": {
"style": "long",
"color": "#eeeef2"
},
"glasses": "none",
"brows": "thick",
"top": {
"style": "robe",
"color": "#a8865a",
"accent": "#6b4a2a"
},
"bottom": {
"style": "pants",
"color": "#2c3346"
},
"shoes": "#6b4a2a",
"footwear": "sandals",
"nose": "long",
"lids": 0.5,
"wrinkles": 0.85,
"head": "oval"
},
"caption": "Construtor da arca",
"description": "idoso de 600 anos, barba branca longa, cabelo longo grisalho, túnica, sandália, rugas, pálpebra caída, olhar sereno, magro",
"createdAt": "2026-11-18T03:23:13.290Z",
"updatedAt": "2026-11-18T03:23:57.049Z"
}
+40
View File
@@ -0,0 +1,40 @@
{
"schemaVersion": 1,
"id": "sem",
"name": "Sem",
"kind": "cartoon",
"look": {
"build": "average",
"height": 1.02,
"skin": "#c08055",
"hair": {
"style": "short",
"color": "#6b4226"
},
"beard": {
"style": "full",
"color": "#6b4226"
},
"glasses": "none",
"brows": "thin",
"top": {
"style": "robe",
"color": "#2f6db3",
"accent": "#6b4a2a"
},
"bottom": {
"style": "pants",
"color": "#2c3346"
},
"shoes": "#6b4a2a",
"footwear": "sandals",
"nose": "round",
"lids": 0.1,
"wrinkles": 0.4,
"head": "round"
},
"caption": "Filho de Noé",
"description": "homem de 45 anos, barba cheia castanha, cabelo curto castanho, túnica azul, sandália",
"createdAt": "2026-11-18T03:23:14.006Z",
"updatedAt": "2026-11-18T03:23:57.118Z"
}
@@ -0,0 +1,93 @@
Copyright 2017 The Barlow Project Authors (https://github.com/jpt/barlow)
This Font Software is licensed under the SIL Open Font License, Version 1.1.
This license is copied below, and is also available with a FAQ at:
http://scripts.sil.org/OFL
-----------------------------------------------------------
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
-----------------------------------------------------------
PREAMBLE
The goals of the Open Font License (OFL) are to stimulate worldwide
development of collaborative font projects, to support the font creation
efforts of academic and linguistic communities, and to provide a free and
open framework in which fonts may be shared and improved in partnership
with others.
The OFL allows the licensed fonts to be used, studied, modified and
redistributed freely as long as they are not sold by themselves. The
fonts, including any derivative works, can be bundled, embedded,
redistributed and/or sold with any software provided that any reserved
names are not used by derivative works. The fonts and derivatives,
however, cannot be released under any other type of license. The
requirement for fonts to remain under this license does not apply
to any document created using the fonts or their derivatives.
DEFINITIONS
"Font Software" refers to the set of files released by the Copyright
Holder(s) under this license and clearly marked as such. This may
include source files, build scripts and documentation.
"Reserved Font Name" refers to any names specified as such after the
copyright statement(s).
"Original Version" refers to the collection of Font Software components as
distributed by the Copyright Holder(s).
"Modified Version" refers to any derivative made by adding to, deleting,
or substituting -- in part or in whole -- any of the components of the
Original Version, by changing formats or by porting the Font Software to a
new environment.
"Author" refers to any designer, engineer, programmer, technical
writer or other person who contributed to the Font Software.
PERMISSION & CONDITIONS
Permission is hereby granted, free of charge, to any person obtaining
a copy of the Font Software, to use, study, copy, merge, embed, modify,
redistribute, and sell modified and unmodified copies of the Font
Software, subject to the following conditions:
1) Neither the Font Software nor any of its individual components,
in Original or Modified Versions, may be sold by itself.
2) Original or Modified Versions of the Font Software may be bundled,
redistributed and/or sold with any software, provided that each copy
contains the above copyright notice and this license. These can be
included either as stand-alone text files, human-readable headers or
in the appropriate machine-readable metadata fields within text or
binary files as long as those fields can be easily viewed by the user.
3) No Modified Version of the Font Software may use the Reserved Font
Name(s) unless explicit written permission is granted by the corresponding
Copyright Holder. This restriction only applies to the primary font name as
presented to the users.
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
Software shall not be used to promote, endorse or advertise any
Modified Version, except to acknowledge the contribution(s) of the
Copyright Holder(s) and the Author(s) or with their explicit written
permission.
5) The Font Software, modified or unmodified, in part or in whole,
must be distributed entirely under this license, and must not be
distributed under any other license. The requirement for fonts to
remain under this license does not apply to any document created
using the Font Software.
TERMINATION
This license becomes null and void if any of the above conditions are
not met.
DISCLAIMER
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
OTHER DEALINGS IN THE FONT SOFTWARE.
Binary file not shown.
+3 -1
View File
@@ -26,6 +26,8 @@
"exports": { "exports": {
"./character": "./src/character.ts", "./character": "./src/character.ts",
"./figure": "./src/CharacterFigure.tsx", "./figure": "./src/CharacterFigure.tsx",
"./spec": "./src/spec.ts" "./spec": "./src/spec.ts",
"./motion": "./src/motion.ts",
"./rig": "./src/rig.ts"
} }
} }
+36
View File
@@ -45,6 +45,42 @@ function readJobs(): Job[] {
async function still() { async function still() {
const propsFile = arg("props"); const propsFile = arg("props");
const out = arg("out"); const out = arg("out");
// `--still --spec <trecho.json> --out <png> [--frame N]`: um quadro de um trecho (conferir peças sem gerar o vídeo).
// `--still --list <lista.json>` ([{spec, out, frame?}]): vários quadros num empacotamento só (folhas de conferência).
const listFile = arg("list");
if (listFile) {
const list = JSON.parse(fs.readFileSync(resolve(listFile), "utf8")) as { spec: string; out: string; frame?: number }[];
const serveUrl = await bundle({ entryPoint: path.join(HERE, "src", "index.ts"), publicDir: path.join(REPO, "assets") });
const results: { out: string; frames: number; ms: number }[] = [];
for (const item of list) {
const t0 = Date.now();
const spec = JSON.parse(fs.readFileSync(resolve(item.spec), "utf8")) as ShotSpec;
const errors = validateSpec(spec);
if (errors.length) throw new Error(`${item.spec}: ${errors.join("; ")}`);
const inputProps = spec as unknown as Record<string, unknown>;
const composition = await selectComposition({ serveUrl, id: "Shot", inputProps });
fs.mkdirSync(path.dirname(resolve(item.out)), { recursive: true });
const frame = Math.min(frameCount(spec) - 1, item.frame ?? Math.floor(frameCount(spec) / 2));
await renderStill({ composition, serveUrl, inputProps, output: resolve(item.out), frame, imageFormat: "png", browserExecutable: process.env.CARTOON_CHROME || null });
results.push({ out: path.relative(REPO, resolve(item.out)).replace(/\\/g, "/"), frames: 1, ms: Date.now() - t0 });
}
console.log(JSON.stringify({ ok: true, results }));
return;
}
const specFile = arg("spec");
if (specFile && out) {
const spec = JSON.parse(fs.readFileSync(resolve(specFile), "utf8")) as ShotSpec;
const errors = validateSpec(spec);
if (errors.length) throw new Error(`spec: ${errors.join("; ")}`);
const serveUrl = await bundle({ entryPoint: path.join(HERE, "src", "index.ts"), publicDir: path.join(REPO, "assets") });
const inputProps = spec as unknown as Record<string, unknown>;
const composition = await selectComposition({ serveUrl, id: "Shot", inputProps });
fs.mkdirSync(path.dirname(resolve(out)), { recursive: true });
const frame = Math.min(frameCount(spec) - 1, Number(arg("frame") ?? Math.floor(frameCount(spec) / 2)));
await renderStill({ composition, serveUrl, inputProps, output: resolve(out), frame, imageFormat: "png", browserExecutable: process.env.CARTOON_CHROME || null });
console.log(JSON.stringify({ ok: true, results: [{ out: path.relative(REPO, resolve(out)).replace(/\\/g, "/"), frames: 1, ms: 0 }] }));
return;
}
if (!propsFile || !out) throw new Error("--still precisa de --props e --out"); if (!propsFile || !out) throw new Error("--still precisa de --props e --out");
const inputProps = JSON.parse(fs.readFileSync(resolve(propsFile), "utf8")) as Record<string, unknown>; const inputProps = JSON.parse(fs.readFileSync(resolve(propsFile), "utf8")) as Record<string, unknown>;
const looks = (inputProps.figures as { look: unknown }[] | undefined) ?? []; const looks = (inputProps.figures as { look: unknown }[] | undefined) ?? [];
+15 -4
View File
@@ -3,7 +3,7 @@
import React from "react"; import React from "react";
import { AbsoluteFill, useCurrentFrame, useVideoConfig } from "remotion"; import { AbsoluteFill, useCurrentFrame, useVideoConfig } from "remotion";
import { CharacterFigure } from "./CharacterFigure"; import { CharacterFigure } from "./CharacterFigure";
import { TagLabel } from "./overlays"; import { Grain, TagLabel } from "./overlays";
import { loadFonts } from "./theme"; import { loadFonts } from "./theme";
import type { CharacterLook, Expression, Pose } from "./character"; import type { CharacterLook, Expression, Pose } from "./character";
import type { IconId } from "./spec"; import type { IconId } from "./spec";
@@ -13,25 +13,36 @@ loadFonts();
export type CardProps = { export type CardProps = {
width: number; height: number; width: number; height: number;
background?: string; background?: string;
/** "face": enquadra só a cabeça (conferir expressões de perto). */
framing?: "full" | "face";
figures: { look: CharacterLook; expression?: Expression; pose?: Pose; item?: IconId; label?: string }[]; figures: { look: CharacterLook; expression?: Expression; pose?: Pose; item?: IconId; label?: string }[];
}; };
export function CharacterCard({ figures, background = "#2a2e45" }: CardProps) { export function CharacterCard({ figures, background = "#2a2e45", framing = "full" }: CardProps) {
const frame = useCurrentFrame(); const frame = useCurrentFrame();
const { fps } = useVideoConfig(); const { fps } = useVideoConfig();
const n = Math.max(1, figures.length); const n = Math.max(1, figures.length);
return ( return (
<AbsoluteFill style={{ background, containerType: "size" }}> <AbsoluteFill style={{ background, containerType: "size" }}>
<div style={{ position: "absolute", inset: "8% 2% 4%", display: "grid", gridTemplateColumns: `repeat(${n}, 1fr)`, alignItems: "end" }}> <div style={{ position: "absolute", inset: "8% 2% 4%", display: "grid", gridTemplateColumns: `repeat(${n}, minmax(0, 1fr))`, alignItems: "end" }}>
{figures.map((f, i) => ( {figures.map((f, i) => (
<div key={i} style={{ position: "relative", height: "100%", display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "flex-end" }}> <div key={i} style={{ position: "relative", height: "100%", display: "flex", flexDirection: "column", alignItems: "center", justifyContent: "flex-end" }}>
{f.label && <div style={{ marginBottom: "4%" }}><TagLabel text={f.label} size={n > 3 ? 2.2 : 3.4} /></div>} {f.label && <div style={{ marginBottom: "4%" }}><TagLabel text={f.label} size={n > 3 ? 2.2 : 3.4} /></div>}
<div style={{ width: "90%", aspectRatio: "200 / 440", maxHeight: "86%" }}> {framing === "face" ? (
<div style={{ width: "92%", aspectRatio: "1 / 1", overflow: "hidden", position: "relative" }}>
<div style={{ position: "absolute", left: "-15%", top: "-36%", width: "130%", aspectRatio: "200 / 440" }}>
<CharacterFigure look={f.look} expression={f.expression} pose={f.pose} item={f.item} t={frame / fps} /> <CharacterFigure look={f.look} expression={f.expression} pose={f.pose} item={f.item} t={frame / fps} />
</div> </div>
</div> </div>
) : (
<div style={{ width: "90%", aspectRatio: "200 / 440", maxHeight: "86%" }}>
<CharacterFigure look={f.look} expression={f.expression} pose={f.pose} item={f.item} t={frame / fps} />
</div>
)}
</div>
))} ))}
</div> </div>
<Grain />
</AbsoluteFill> </AbsoluteFill>
); );
} }
+735 -150
View File
@@ -1,199 +1,784 @@
// Desenho do personagem a partir das peças (character.ts). SVG puro, sem Remotion: o painel usa o mesmo // Desenho do personagem a partir do RIG (rig.ts): rosto e corpo por parâmetros contínuos, braços e pernas em
// componente na prévia ao vivo da aba Personagens. viewBox 200×440 com os pés em (100, 440). // dois segmentos (ombro/cotovelo, quadril/joelho). SVG puro, sem Remotion: o painel usa o mesmo componente.
// `t` (segundos) só move detalhes vivos: respiração, piscar, braço acenando. // viewBox 200×440, pés em (100, 440). O movimento (andar, pular, falar…) vem de motion.ts como `state`; sem ele,
import React from "react"; // usa a expressão/pose pedida com a "vida" (piscar, respirar). Posição, giro e espelho ficam por conta de quem
// desenha a cena (Shot.tsx).
//
// Acabamento de ilustração (v2): cabeça grande (~1/3 da altura), tronco em "pera" com ombros redondos, membros
// afinando na ponta, SOMBREADO CEL em 2 tons em tudo (luz de um lado só, `shadeSide`), sem contorno preto (a borda
// é o tom escuro da própria cor), sobrancelha como forma, nariz de traço, pálpebra pesada, mãos com dedos que
// seguram o objeto por cima, roupa com gola/zíper/botões/dobras/barra e sapato com volume.
import React, { useId } from "react";
import { Icon } from "./icons"; import { Icon } from "./icons";
import type { IconId } from "./spec"; import type { IconId } from "./spec";
import { DEFAULT_LOOK, type CharacterLook, type Expression, type Pose } from "./character"; import { DEFAULT_LOOK, type CharacterLook } from "./character";
import { evaluate, type ActorState } from "./motion";
import { POSE_PRESETS, type BodyParams, type FaceParams, type Limb } from "./rig";
import { armLayer } from "./limbs";
import { GRIP, HandArt, TWO_HANDED, handPlacement, wristForHold, type HandShape } from "./hands";
const INK = "#15161f"; const INK = "#1d1a22";
/** Escala da cabeça sobre o desenho-base da cabeça (centro (100,106), queixo em y 156). */
const HEAD_SCALE = 1.2;
/** Ângulo dos braços por pose (graus; 0 = para baixo). Direito negativo = para fora; esquerdo positivo = para fora. */ export function shade(hex: string, k: number): string {
const ARMS: Record<Pose, [number, number]> = {
stand: [-8, 8], point: [-95, 8], wave: [-150, 8], hold: [-38, 8], arms_up: [-160, 160], shrug: [-55, 55], think: [150, 8],
};
function shade(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16); const n = parseInt(hex.slice(1), 16);
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v * k))).toString(16).padStart(2, "0"); const c = (v: number) => Math.max(0, Math.min(255, Math.round(v * k))).toString(16).padStart(2, "0");
return `#${c((n >> 16) & 255)}${c((n >> 8) & 255)}${c(n & 255)}`; return `#${c((n >> 16) & 255)}${c((n >> 8) & 255)}${c(n & 255)}`;
} }
/** Sombra com um pouco de azul (sombra fria sob luz quente, como na ilustração). */
function Mouth({ expression }: { expression: Expression }) { function cool(hex: string, k = 0.78): string {
const common = { stroke: INK, strokeWidth: 4.5, fill: "none", strokeLinecap: "round" as const }; const n = parseInt(hex.slice(1), 16);
switch (expression) { const r = ((n >> 16) & 255) * k * 0.94, g = ((n >> 8) & 255) * k * 0.97, b = (n & 255) * k + 10;
case "happy": return <path d="M84 131 Q100 150 116 131 Q100 140 84 131 Z" fill={INK} />; const c = (v: number) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
case "sad": return <path d="M87 141 Q100 129 113 141" {...common} />; return `#${c(r)}${c(g)}${c(b)}`;
case "worried": return <path d="M86 139 Q93 133 100 139 Q107 145 114 139" {...common} />;
case "angry": return <path d="M87 139 L113 136" {...common} strokeWidth={6} />;
case "surprised": return <ellipse cx={100} cy={139} rx={8} ry={10} fill={INK} />;
case "scared": return <ellipse cx={100} cy={140} rx={10} ry={7} fill={INK} />;
default: return <path d="M88 136 Q100 140 112 136" {...common} />;
}
} }
/** Ponta de um segmento: ângulo de tela em graus (0 = para baixo). */
const tip = (x: number, y: number, deg: number, len: number) => {
const r = (deg * Math.PI) / 180;
return { x: x - Math.sin(r) * len, y: y + Math.cos(r) * len };
};
function Brows({ expression, thick, color }: { expression: Expression; thick: boolean; color: string }) { /**
// Inclinação da sobrancelha esquerda (a direita espelha): + sobe por dentro (triste/preocupado), − desce (bravo). * Forma com sombra cel: desenha a forma no tom da sombra e por cima a cópia iluminada deslocada para o lado da
const tilt = { neutral: 0, happy: -6, sad: 16, worried: 14, angry: -18, surprised: 0, scared: 18 }[expression]; * luz, recortada pela própria forma. Sobra um crescente de sombra no lado oposto à luz (e embaixo).
const lift = expression === "surprised" || expression === "scared" ? -7 : expression === "happy" ? -3 : 0; */
const w = thick ? 7 : 4.5; function Cel({ id, d, fill, side, dx = 8, dy = -4, k = 0.8, transform }: { id: string; d: string; fill: string; side: number; dx?: number; dy?: number; k?: number; transform?: string }) {
return ( return (
<g stroke={color} strokeWidth={w} strokeLinecap="round"> <g transform={transform}>
<line x1={71} y1={89 + lift} x2={92} y2={89 + lift} transform={`rotate(${tilt} 92 ${89 + lift})`} /> <defs><clipPath id={id}><path d={d} /></clipPath></defs>
<line x1={108} y1={89 + lift} x2={129} y2={89 + lift} transform={`rotate(${-tilt} 108 ${89 + lift})`} /> <g clipPath={`url(#${id})`}>
<path d={d} fill={cool(fill, k)} />
<path d={d} fill={fill} transform={`translate(${-side * dx} ${dy})`} />
</g>
</g> </g>
); );
} }
function Eyes({ expression, t }: { expression: Expression; t: number }) { /** Membro afinando (ombro→cotovelo, cotovelo→punho, quadril→joelho…), com sombra cel no lado oposto à luz. */
const big = expression === "surprised" || expression === "scared"; export function Limb2({ id, x, y, deg, len, w1, w2, fill, side }: { id: string; x: number; y: number; deg: number; len: number; w1: number; w2: number; fill: string; side: number }) {
const r = big ? 12.5 : 10.5; const d = `M${-w1 / 2} 0 L${-w2 / 2} ${len} A${w2 / 2} ${w2 / 2} 0 0 0 ${w2 / 2} ${len} L${w1 / 2} 0 A${w1 / 2} ${w1 / 2} 0 0 0 ${-w1 / 2} 0 Z`;
const pupil = expression === "scared" ? 3.4 : big ? 5.5 : 5; // A sombra fica do lado da tela oposto à luz; no sistema local do membro esse lado gira junto.
const blink = (t % 3.7) < 0.12 && !big ? 0.12 : 1; const r = (deg * Math.PI) / 180;
const squint = expression === "angry" ? 0.7 : expression === "happy" ? 0.8 : 1; const local = Math.cos(r) >= 0 ? side : -side;
return <Cel id={id} d={d} fill={fill} side={local} dx={w1 * 0.32} dy={0} transform={`translate(${x} ${y}) rotate(${deg})`} />;
}
function Mouth({ f, uid, skin }: { f: FaceParams; uid: string; skin: string }) {
const w = 30 * f.mouthWidth * (1 - f.mouthRound * 0.35);
const cy = 138 - f.smile * 6;
if (f.mouthOpen < 0.06 && f.mouthRound < 0.3) {
return ( return (
<g> <g>
{[82, 118].map((x) => ( <path d={`M${100 - w / 2} ${cy} Q100 ${138 + f.smile * 12} ${100 + w / 2} ${cy}`} stroke={shade(skin, 0.42)} strokeWidth={4.6} fill="none" strokeLinecap="round" />
<g key={x} transform={`translate(${x} 108) scale(1 ${blink * squint})`}> {/* Lábio de baixo: sombra curta sob a boca. */}
<circle r={r} fill="#ffffff" /> <path d={`M${100 - w * 0.22} ${cy + 7 + f.smile * 5} Q100 ${cy + 10 + f.smile * 6} ${100 + w * 0.22} ${cy + 7 + f.smile * 5}`} stroke={shade(skin, 0.82)} strokeWidth={3} fill="none" strokeLinecap="round" />
<circle r={pupil} cx={expression === "worried" ? -1.5 : 0} cy={expression === "sad" ? 2 : 0} fill={INK} />
</g>
))}
</g> </g>
); );
} }
const open = Math.max(f.mouthOpen, f.mouthRound * 0.25);
// A curva quadrática só chega à metade do ponto de controle: os controles ficam no dobro da abertura desejada.
const up = cy + f.smile * 2 - open * 8 - f.mouthRound * 6;
// A boca aberta (riso, grito) nunca passa do queixo (y ≈ 156): cresce até ali e para.
const low = Math.min(152, cy + open * 44 * (1 + f.mouthRound * 0.3) + f.smile * 12);
const d = `M${100 - w / 2} ${cy} Q100 ${up} ${100 + w / 2} ${cy} Q100 ${low} ${100 - w / 2} ${cy} Z`;
return (
<g>
<defs><clipPath id={`m${uid}`}><path d={d} /></clipPath></defs>
<path d={d} fill="#4a1f24" />
<g clipPath={`url(#m${uid})`}>
{f.teeth && open > 0.12 && <rect x={60} y={Math.min(up, cy) - 10} width={80} height={(cy - Math.min(up, cy)) + 10 + (low - cy) * 0.16} fill="#f7f4ec" />}
{open > 0.35 && <ellipse cx={100} cy={cy + (low - cy) * 0.55} rx={w * 0.32} ry={(low - cy) * 0.2} fill="#d9606a" />}
</g>
</g>
);
}
function Eyes({ f, lid, skin, uid }: { f: FaceParams; lid: number; skin: string; uid: string }) {
const big = Math.max(f.eyeL, f.eyeR);
const r = 11 + Math.max(0, big - 1) * 7;
const cover = Math.max(0, Math.min(0.85, lid));
const lidColor = shade(skin, 0.96);
const crease = shade(skin, 0.7);
const eye = (x: number, open: number, sideSign: number) => {
// Olho de riso: fechado em arco para cima quando quase fechado e sorrindo.
if (open < 0.3 && f.smile > 0.55) return <path key={x} d={`M${x - 11} 110 Q${x} 97 ${x + 11} 110`} stroke={INK} strokeWidth={4.5} fill="none" strokeLinecap="round" />;
if (open < 0.14) return <path key={x} d={`M${x - 11} 108 Q${x} 114 ${x + 11} 108`} stroke={shade(skin, 0.45)} strokeWidth={4} fill="none" strokeLinecap="round" />;
const rx = r * 1.12;
return (
<g key={x} transform={`translate(${x} 108) scale(1 ${Math.min(1.2, open)})`}>
<defs><clipPath id={`e${uid}${x}`}><ellipse rx={rx} ry={r} /></clipPath></defs>
{/* Cavidade: leve sombra ao redor do olho. */}
<ellipse rx={rx + 3} ry={r + 2.5} fill={shade(skin, 0.9)} />
<ellipse rx={rx} ry={r} fill="#fbfaf6" />
<g clipPath={`url(#e${uid}${x})`}>
<ellipse cx={0} cy={-r * 0.55} rx={rx} ry={r * 0.5} fill="#000" opacity={0.07} />
<circle r={Math.max(2.6, 4.6 * f.pupil + 0.6)} cx={f.gazeX * 4.5 + sideSign * 0.6} cy={f.gazeY * 3 + cover * 3.5 + 1} fill="#2a2228" />
<circle r={1.5} cx={f.gazeX * 4.5 + 1.6} cy={f.gazeY * 3 - 1 + cover * 3.5} fill="#ffffff" opacity={0.9} />
{cover > 0.02 && <>
<rect x={-rx - 1} y={-r - 1} width={2 * rx + 2} height={2 * r * cover + 1} fill={lidColor} />
<path d={`M${-rx} ${-r + 2 * r * cover} Q0 ${-r + 2 * r * cover + 3.5} ${rx} ${-r + 2 * r * cover}`} stroke={crease} strokeWidth={3} fill="none" />
</>}
</g>
{/* Dobra da pálpebra acima do olho. */}
<path d={`M${-rx * 0.9} ${-r - 3} Q0 ${-r - 8} ${rx * 0.9} ${-r - 3}`} stroke={crease} strokeWidth={2.2} fill="none" strokeLinecap="round" opacity={0.75} />
</g>
);
};
return <g>{eye(81, f.eyeL, -1)}{eye(119, f.eyeR, 1)}</g>;
}
/** Sobrancelha como FORMA grossa (afina na ponta de fora), girando pelo rig. */
function Brows({ f, thick, color }: { f: FaceParams; thick: boolean; color: string }) {
const h = thick ? 8 : 5.5;
const brow = (x0: number, x1: number, y: number, tilt: number, pivotX: number, inner: number) => {
// Ponta de dentro (pivô) mais grossa; a de fora afina.
const outer = x0 === pivotX ? x1 : x0;
const d = `M${pivotX} ${y - h * 0.55} Q${(pivotX + outer) / 2} ${y - h * 1.15} ${outer} ${y - h * 0.1} Q${(pivotX + outer) / 2} ${y + h * 0.15} ${pivotX} ${y + h * 0.55} Z`;
return <path d={d} fill={color} transform={`rotate(${inner * tilt} ${pivotX} ${y})`} />;
};
return (
<g>
{brow(68, 93, 88 + f.browL.y, f.browL.tilt, 93, -1)}
{brow(107, 132, 88 + f.browR.y, f.browR.tilt, 107, 1)}
</g>
);
}
function Extras({ f, t, skin }: { f: FaceParams; t: number; skin: string }) {
return (
<g>
{/* Bochechas: rubor leve sempre; mais forte com vergonha. */}
<ellipse cx={72} cy={126} rx={12} ry={7} fill="#e8707a" opacity={0.16 + 0.45 * f.blush} />
<ellipse cx={128} cy={126} rx={12} ry={7} fill="#e8707a" opacity={0.16 + 0.45 * f.blush} />
{f.sweat && <path d="M148 74 Q155 87 148 94 Q141 87 148 74 Z" fill="#9fdcff" />}
{f.tears && [80, 120].map((x, i) => {
const k = ((t * 1.4 + i * 0.5) % 1);
return <path key={x} d={`M${x} ${118 + k * 26} q4 6 0 9 q-4 -3 0 -9 Z`} fill="#9fdcff" opacity={1 - k * 0.6} />;
})}
{f.anger && <g stroke="#e8463d" strokeWidth={4} strokeLinecap="round" fill="none"><path d="M130 60 q6 4 12 0" /><path d="M130 72 q6 -4 12 0" /><path d="M130 60 q-4 6 0 12" /><path d="M142 60 q4 6 0 12" /></g>}
{skin && null}
</g>
);
}
function Beard({ style, color, uid, side }: { style: CharacterLook["beard"]["style"]; color: string; uid: string; side: number }) {
const strands = (d: string) => <path d={d} stroke={shade(color, 1.18)} strokeWidth={2.2} fill="none" strokeLinecap="round" opacity={0.6} />;
switch (style) {
case "full": {
const d = "M54 106 Q56 166 100 174 Q144 166 146 106 Q140 128 125 127 Q100 122 75 127 Q60 128 54 106 Z";
return <g><Cel id={`bd${uid}`} d={d} fill={color} side={side} dx={9} />{strands("M78 150 Q84 162 92 166 M108 166 Q116 162 122 150")}
<path d="M74 136 Q80 118 100 122 Q120 118 126 136 Q113 129 100 132 Q87 129 74 136 Z" fill={shade(color, 0.9)} /></g>;
}
case "stubble": return <path d="M58 116 Q62 164 100 168 Q138 164 142 116 Q130 133 100 129 Q70 133 58 116 Z" fill={color} opacity={0.3} />;
case "goatee": return <g><path d="M86 150 Q100 172 114 150 Q100 157 86 150 Z" fill={color} /><path d="M80 136 Q88 124 100 127 Q112 124 120 136 Q110 131 100 133 Q90 131 80 136 Z" fill={color} /></g>;
case "mustache": return (
<g>
{/* Bigode cheio, com volume (claro em cima, escuro embaixo). */}
<path d="M70 140 Q74 116 100 121 Q126 116 130 140 Q120 131 110 134 Q104 128 100 129 Q96 128 90 134 Q80 131 70 140 Z" fill={color} />
<path d="M72 138 Q80 132 90 134 Q96 128 100 129 Q104 128 110 134 Q120 132 128 138 Q118 137 110 137 Q100 133 90 137 Q80 137 72 138 Z" fill={shade(color, 0.78)} />
{strands("M84 126 L86 131 M96 124 L97 129 M106 124 L105 129 M116 126 L114 131")}
</g>
);
// Barba longa: desce do rosto até o peito em ponta, com fios marcados e bigode por cima.
case "long": {
const d = "M54 104 Q52 152 68 192 Q84 230 100 246 Q116 230 132 192 Q148 152 146 104 Q138 128 124 126 Q100 121 76 126 Q62 128 54 104 Z";
return (
<g>
<Cel id={`bd${uid}`} d={d} fill={color} side={side} dx={12} dy={-2} k={0.84} />
<path d="M80 160 Q84 196 94 222 M100 168 L100 236 M120 160 Q116 196 106 222 M68 140 Q70 170 78 192 M132 140 Q130 170 122 192" stroke={shade(color, 0.82)} strokeWidth={2.6} fill="none" strokeLinecap="round" />
<path d="M72 138 Q80 118 100 122 Q120 118 128 138 Q114 130 100 133 Q86 130 72 138 Z" fill={shade(color, 0.9)} />
</g>
);
}
default: return null;
}
}
/** Nariz: traço curvo simples no tom escuro da pele (padrão, como na ilustração) ou formas cheias. */
function Nose({ kind, skin }: { kind: CharacterLook["nose"]; skin: string }) {
const dark = shade(skin, 0.62);
const shadow = <ellipse cx={101} cy={131} rx={9} ry={3} fill={shade(skin, 0.82)} opacity={0.8} />;
switch (kind) {
case "round": return <>{shadow}<circle cx={100} cy={121} r={10} fill={shade(skin, 0.93)} /><path d="M92 126 Q100 132 108 126" stroke={dark} strokeWidth={2.8} fill="none" strokeLinecap="round" /><circle cx={96} cy={117} r={2.6} fill="#ffffff" opacity={0.35} /></>;
case "long": return <>{shadow}<path d="M98 102 Q104 116 106 126 Q101 132 93 128" stroke={dark} strokeWidth={3.4} fill="none" strokeLinecap="round" strokeLinejoin="round" /></>;
case "wide": return <>{shadow}<path d="M88 126 Q92 116 100 116 Q108 116 112 126 Q106 131 100 129 Q94 131 88 126 Z" fill={shade(skin, 0.92)} /><path d="M89 126 Q94 131 100 129 Q106 131 111 126" stroke={dark} strokeWidth={2.6} fill="none" strokeLinecap="round" /></>;
case "button": return <>{shadow}<path d="M95 124 Q100 128 105 124" stroke={dark} strokeWidth={3} fill="none" strokeLinecap="round" /></>;
default: return <>{shadow}<path d="M99 106 Q89 121 95 127 Q101 131 107 126" stroke={dark} strokeWidth={3.6} fill="none" strokeLinecap="round" /></>;
}
}
function Wrinkles({ k, skin }: { k: number; skin: string }) {
if (k <= 0.05) return null;
const c = shade(skin, 0.8);
return (
<g stroke={c} strokeWidth={2.6} fill="none" strokeLinecap="round" opacity={Math.min(0.85, 0.4 + k * 0.4)}>
{/* Testa: arcos suaves no tom da pele. */}
<path d="M78 70 Q100 62 122 70" />
{k > 0.3 && <path d="M83 78 Q100 72 117 78" />}
{k > 0.6 && <path d="M88 63 Q100 58 112 63" />}
{k > 0.5 && <><path d="M60 104 l-6 -3 M60 110 l-7 0" /><path d="M140 104 l6 -3 M140 110 l7 0" /></>}
{k > 0.4 && <><path d="M75 126 Q70 137 75 146" /><path d="M125 126 Q130 137 125 146" /><path d="M74 120 Q81 123 88 121" opacity={0.6} /><path d="M112 121 Q119 123 126 120" opacity={0.6} /></>}
</g>
);
}
/** Formato da cabeça (centro (100,106)). */
function headPath(shape: CharacterLook["head"]): string {
switch (shape) {
case "oval": return "M100 52 C127 52 144 76 144 106 C144 141 124 162 100 162 C76 162 56 141 56 106 C56 76 73 52 100 52 Z";
case "square": return "M100 54 C131 54 149 71 149 100 L148 128 C146 151 127 160 100 160 C73 160 54 151 52 128 L51 100 C51 71 69 54 100 54 Z";
case "wide": return "M100 56 C128 56 146 72 149 98 C153 128 142 158 100 160 C58 158 47 128 51 98 C54 72 72 56 100 56 Z";
default: return "M100 54 C127 54 148 77 148 106 C148 135 127 158 100 158 C73 158 52 135 52 106 C52 77 73 54 100 54 Z";
}
}
function Glasses({ kind }: { kind: CharacterLook["glasses"] }) { function Glasses({ kind }: { kind: CharacterLook["glasses"] }) {
if (kind === "none") return null; if (kind === "none") return null;
const lens = kind === "sun" ? INK : "none"; const frame = kind === "sun" ? "#1c1a20" : "#4a2e1e";
const lens = (x: number) => kind === "square"
? <rect x={x - 17} y={94} width={34} height={28} rx={7} />
: <ellipse cx={x} cy={108} rx={17} ry={15} />;
return ( return (
<g stroke={INK} strokeWidth={4} fill={lens}> <g>
{kind === "square" <g fill={kind === "sun" ? "#1c1a20" : "#ffffff"} opacity={kind === "sun" ? 0.92 : 0.1}>{lens(81)}{lens(119)}</g>
? <><rect x={67} y={95} width={30} height={25} rx={5} /><rect x={103} y={95} width={30} height={25} rx={5} /></> {/* Reflexo diagonal na lente. */}
: <><circle cx={82} cy={108} r={15} /><circle cx={118} cy={108} r={15} /></>} <g stroke="#ffffff" strokeWidth={3} strokeLinecap="round" opacity={kind === "sun" ? 0.5 : 0.45}><path d="M71 101 L78 96" /><path d="M109 101 L116 96" /></g>
<line x1={97} y1={107} x2={103} y2={107} /> <g stroke={frame} strokeWidth={4.4} fill="none">{lens(81)}{lens(119)}</g>
<line x1={55} y1={104} x2={67} y2={106} /><line x1={133} y1={106} x2={145} y2={104} /> <path d="M97 106 Q100 103 103 106" stroke={frame} strokeWidth={4} fill="none" />
<path d="M52 103 L64 105 M136 105 L148 103" stroke={frame} strokeWidth={5} strokeLinecap="round" />
</g> </g>
); );
} }
function Beard({ style, color }: { style: CharacterLook["beard"]["style"]; color: string }) { function HairFront({ look, uid, side }: { look: CharacterLook; uid: string; side: number }) {
switch (style) {
case "full": return <path d="M56 108 Q58 168 100 172 Q142 168 144 108 Q138 128 124 126 Q100 122 76 126 Q62 128 56 108 Z" fill={color} />;
case "stubble": return <path d="M60 116 Q64 162 100 166 Q136 162 140 116 Q130 132 100 128 Q70 132 60 116 Z" fill={color} opacity={0.35} />;
case "goatee": return <path d="M88 146 Q100 166 112 146 Q100 152 88 146 Z" fill={color} />;
case "mustache": return <path d="M82 128 Q100 120 118 128 Q110 134 100 130 Q90 134 82 128 Z" fill={color} />;
default: return null;
}
}
function HairBack({ look }: { look: CharacterLook }) {
if (look.hair.style !== "long") return null;
return <path d="M50 100 Q48 40 100 38 Q152 40 150 100 L156 190 Q100 205 44 190 Z" fill={look.hair.color} />;
}
function HairFront({ look }: { look: CharacterLook }) {
const c = look.hair.color; const c = look.hair.color;
const lite = shade(c, 1.25);
const cel = (d: string, k = 0.78) => <Cel id={`hf${uid}`} d={d} fill={c} side={side} dx={10} dy={4} k={k} />;
switch (look.hair.style) { switch (look.hair.style) {
case "bald": return <><path d="M53 112 Q50 86 62 80 L62 112 Z" fill={c} /><path d="M147 112 Q150 86 138 80 L138 112 Z" fill={c} /></>; case "bald": return <>{cel("M50 100 Q46 78 64 68 Q72 82 62 100 Z M150 100 Q154 78 136 68 Q128 82 138 100 Z")}</>;
case "short": return <path d="M53 104 Q52 50 100 50 Q148 50 147 104 Q140 76 100 74 Q60 76 53 104 Z" fill={c} />; case "short": return <>{cel("M51 104 Q50 48 100 48 Q150 48 149 104 Q141 74 100 72 Q59 74 51 104 Z")}<path d="M70 62 Q86 56 100 58 M110 56 Q124 58 134 66" stroke={lite} strokeWidth={3} fill="none" strokeLinecap="round" opacity={0.6} /></>;
case "side": return <path d="M53 106 Q50 48 104 50 Q150 54 147 104 Q134 70 92 80 Q66 86 53 106 Z" fill={c} />; case "side": return <>{cel("M51 106 Q48 46 104 48 Q152 52 149 104 Q134 68 92 78 Q64 86 51 106 Z")}<path d="M74 70 Q92 60 120 60" stroke={lite} strokeWidth={3} fill="none" strokeLinecap="round" opacity={0.6} /></>;
case "bun": return <><circle cx={100} cy={46} r={20} fill={c} /><path d="M53 104 Q52 52 100 52 Q148 52 147 104 Q138 74 100 72 Q62 74 53 104 Z" fill={c} /></>; case "bun": return <><circle cx={100} cy={42} r={21} fill={shade(c, 0.9)} />{cel("M51 104 Q50 50 100 50 Q150 50 149 104 Q139 72 100 70 Q61 72 51 104 Z")}</>;
case "long": return <path d="M53 108 Q50 50 100 50 Q150 50 147 108 Q136 72 100 70 Q64 72 53 108 Z" fill={c} />; case "long": return <>{cel("M51 110 Q48 48 100 48 Q152 48 149 110 Q137 70 100 68 Q63 70 51 110 Z")}<path d="M72 64 Q88 56 104 58" stroke={lite} strokeWidth={3} fill="none" strokeLinecap="round" opacity={0.55} /></>;
case "curly": return <g fill={c}>{[[60, 84], [72, 64], [90, 54], [110, 54], [128, 64], [140, 84], [100, 62], [80, 74], [120, 74]].map(([x, y], i) => <circle key={i} cx={x} cy={y} r={15} />)}</g>; case "curly": return <g>{[[58, 86], [70, 64], [89, 52], [111, 52], [130, 64], [142, 86], [100, 62], [79, 74], [121, 74]].map(([x, y], i) => <g key={i}><circle cx={x} cy={y} r={16} fill={shade(c, 0.8)} /><circle cx={x - 3} cy={y - 3} r={12} fill={c} /></g>)}</g>;
case "spiky": return <path d="M54 102 L58 66 L72 76 L80 48 L94 70 L104 44 L114 70 L128 50 L132 76 L146 66 L146 102 Q130 80 100 80 Q70 80 54 102 Z" fill={c} />; case "spiky": return cel("M52 102 L56 64 L71 75 L79 46 L94 69 L104 42 L115 69 L129 48 L133 75 L148 64 L148 102 Q130 79 100 79 Q70 79 52 102 Z");
case "cap": return <><path d="M54 96 Q54 50 100 50 Q146 50 146 96 Z" fill={c} /><path d="M120 92 Q160 92 172 100 L120 102 Z" fill={shade(c, 0.8)} /></>; case "cap": return <><Cel id={`hf${uid}`} d="M52 96 Q52 46 100 46 Q148 46 148 96 Z" fill={c} side={side} dx={10} dy={4} /><path d="M118 92 Q162 90 176 100 L118 103 Z" fill={shade(c, 0.78)} /><circle cx={100} cy={47} r={4} fill={shade(c, 0.7)} /></>;
default: return null; default: return null;
} }
} }
function Torso({ look, w }: { look: CharacterLook; w: number }) { /** Cabeça inteira no sistema de 200×440 (centro ~ (100,106)); `turn` desloca o rosto para fingir 3/4, `nod` sobe/desce. */
const { top } = look; function Head({ look, f, b, t, uid, side }: { look: CharacterLook; f: FaceParams; b: BodyParams; t: number; uid: string; side: number }) {
const x0 = 100 - 36 * w; // Girar/acenar a cabeça: o rosto anda pouco e o contorno da cabeça acompanha um pouco (senão o rosto parece um
const x1 = 100 + 36 * w; // adesivo descolando). Barba e bigode ficam presos ao queixo (andam junto com o contorno, não com os olhos).
const bottomY = top.style === "dress" ? 345 : 290; const fx = b.headTurn * 6;
const flare = top.style === "dress" ? 14 : 0; const fy = b.headNod * 4;
const body = `M${x0} 172 Q${x0} 158 ${x0 + 14} 156 L${x1 - 14} 156 Q${x1} 158 ${x1} 172 L${x1 + flare} ${bottomY} L${x0 - flare} ${bottomY} Z`; const hx = fx * 0.35;
const accent = top.accent ?? shade(top.color, 1.3); const browColor = look.hair.style === "bald" || look.hair.style === "cap" ? look.beard.color : look.hair.color;
const skinDark = shade(look.skin, 0.72);
return ( return (
<g> <g>
{top.style === "hoodie" && <path d={`M${x0 + 6} 160 Q100 132 ${x1 - 6} 160 Z`} fill={shade(top.color, 0.8)} />} {[52, 148].map((x, i) => (
<path d={body} fill={top.color} /> <g key={x} transform={`translate(${x + b.headTurn * 7} 112) scale(${1 - (i === 0 ? Math.max(0, b.headTurn) : -Math.min(0, b.headTurn)) * 0.5} 1)`}>
{top.style === "uniform" && <rect x={x0} y={248} width={x1 - x0} height={11} fill={accent} />} <ellipse rx={11} ry={15} fill={(i === 0 ? -1 : 1) === side ? cool(look.skin, 0.86) : look.skin} />
{top.style === "shirt" && top.accent && <rect x={x0} y={252} width={x1 - x0} height={9} fill={accent} />} {/* Dobra interna da orelha em tom escuro. */}
{top.style === "jacket" && <><path d={`M100 158 L100 ${bottomY}`} stroke={shade(top.color, 0.6)} strokeWidth={4} /><path d="M86 158 L100 186 L114 158 Z" fill={accent} /></>} <path d={i === 0 ? "M4 -8 Q-5 -2 1 4 Q5 7 2 10" : "M-4 -8 Q5 -2 -1 4 Q-5 7 -2 10"} stroke={skinDark} strokeWidth={3} fill="none" strokeLinecap="round" />
{top.style === "hoodie" && <rect x={84} y={240} width={32} height={22} rx={6} fill={shade(top.color, 0.85)} />}
{top.style === "dress" && [0, 1, 2, 3].map((i) => <circle key={i} cx={84 + (i % 2) * 32} cy={196 + Math.floor(i / 2) * 70} r={3.5} fill="#ffffff" opacity={0.5} />)}
</g> </g>
); ))}
} <g transform={`translate(${hx} 0)`}>
<Cel id={`hd${uid}`} d={headPath(look.head)} fill={look.skin} side={side} dx={14} dy={-8} k={0.8} />
function Legs({ look, w }: { look: CharacterLook; w: number }) { {/* Brilho suave na testa (lado da luz). */}
const { bottom } = look; <ellipse cx={100 - side * 16} cy={72} rx={20} ry={11} fill="#ffffff" opacity={0.1} />
const gap = 10 * w;
const legW = 20 * w;
const left = 100 - gap - legW;
const right = 100 + gap;
const skinTop = look.top.style === "dress" ? 345 : bottom.style === "shorts" ? 330 : bottom.style === "skirt" ? 345 : 440;
return (
<g>
<rect x={left} y={286} width={legW} height={140} rx={6} fill={look.skin} />
<rect x={right} y={286} width={legW} height={140} rx={6} fill={look.skin} />
{look.top.style !== "dress" && bottom.style === "pants" && <><rect x={left} y={284} width={legW} height={142} rx={4} fill={bottom.color} /><rect x={right} y={284} width={legW} height={142} rx={4} fill={bottom.color} /></>}
{look.top.style !== "dress" && bottom.style === "shorts" && <path d={`M${left - 2} 284 L${right + legW + 2} 284 L${right + legW + 2} ${skinTop} L${left - 2} ${skinTop} Z`} fill={bottom.color} />}
{look.top.style !== "dress" && bottom.style === "skirt" && <path d={`M${left + 2} 284 L${right + legW - 2} 284 L${right + legW + 12} ${skinTop} L${left - 12} ${skinTop} Z`} fill={bottom.color} />}
<rect x={left - 4} y={422} width={legW + 10} height={16} rx={7} fill={look.shoes} />
<rect x={right - 6} y={422} width={legW + 10} height={16} rx={7} fill={look.shoes} />
</g> </g>
); <g transform={`translate(${fx} ${fy})`}>
} <Wrinkles k={look.wrinkles ?? 0} skin={look.skin} />
<Extras f={f} t={t} skin={look.skin} />
export function CharacterFigure({ look = DEFAULT_LOOK, expression = "neutral", pose = "stand", item, t = 0 }: {
look?: CharacterLook; expression?: Expression; pose?: Pose; item?: IconId; t?: number;
}) {
const w = look.build === "slim" ? 0.86 : look.build === "heavy" ? 1.22 : 1;
const breathe = Math.sin(t * 2.2) * 1.6;
const [r0, l0] = ARMS[pose];
const swing = pose === "wave" ? Math.sin(t * 9) * 14 : Math.sin(t * 1.4) * 2.5;
const rAngle = r0 + swing;
const lAngle = l0 - (pose === "wave" ? 0 : swing);
const shoulderY = 168;
const sx = 34 * w;
const sleeve = look.top.style === "dress" ? look.skin : look.top.color;
const arm = (side: 1 | -1, angle: number, holds?: IconId) => (
<g transform={`rotate(${angle} ${100 + side * sx} ${shoulderY})`}>
<rect x={100 + side * sx - 9} y={shoulderY - 6} width={18} height={104} rx={9} fill={sleeve} />
<circle cx={100 + side * sx} cy={shoulderY + 102} r={11} fill={look.skin} />
{holds && (
<g transform={`translate(${100 + side * sx - 26} ${shoulderY + 96}) rotate(${-angle} 26 26)`}>
<svg x={0} y={0} width={52} height={52} viewBox="0 0 100 100" overflow="visible"><Icon id={holds} /></svg>
</g> </g>
{/* Barba presa ao queixo: segue o contorno da cabeça e só um pouco o aceno. */}
<g transform={`translate(${hx} ${fy * 0.4})`}>
<Beard style={look.beard.style} color={look.beard.color} uid={uid} side={side} />
</g>
<g transform={`translate(${fx} ${fy})`}>
<Eyes f={f} lid={(look.lids ?? 0) + f.lid} skin={look.skin} uid={uid} />
<Nose kind={look.nose} skin={look.skin} />
<Brows f={f} thick={look.brows === "thick"} color={browColor} />
<Glasses kind={look.glasses} />
<Mouth f={f} uid={uid} skin={look.skin} />
{(look.beard.style === "full" || look.beard.style === "long") && <path d="M74 136 Q80 118 100 122 Q120 118 126 136 Q113 129 100 132 Q87 129 74 136 Z" fill={shade(look.beard.color, 0.9)} opacity={0} />}
</g>
<g transform={`translate(${fx * 0.4} 0)`}><HairFront look={look} uid={uid} side={side} /></g>
{look.accessories?.includes("helmet") && (
<g transform={`translate(${fx * 0.4} 0)`}>
<Cel id={`hm${uid}`} d="M48 92 Q48 38 100 38 Q152 38 152 92 Z" fill={look.accessoryColor ?? "#f2c230"} side={side} dx={12} dy={4} />
<rect x={40} y={88} width={120} height={11} rx={5} fill={shade(look.accessoryColor ?? "#f2c230", 0.82)} />
<path d="M100 40 L100 90" stroke={shade(look.accessoryColor ?? "#f2c230", 0.85)} strokeWidth={8} />
<ellipse cx={78} cy={56} rx={12} ry={6} fill="#ffffff" opacity={0.3} />
</g>
)}
{look.accessories?.includes("headset") && (
<g><path d="M50 100 Q50 42 100 42 Q150 42 150 100" stroke={INK} strokeWidth={6} fill="none" /><rect x={144} y={96} width={14} height={26} rx={6} fill={INK} /><path d="M152 120 Q142 142 116 140" stroke={INK} strokeWidth={3} fill="none" /></g>
)} )}
</g> </g>
); );
}
/**
* Mão: escolhe a forma desenhada da biblioteca (hands.tsx) pelo estado — gesto, apontar, pegada de borda, punho
* segurando, mão no rosto, braço erguido (aberta) ou caída — e a põe no pulso (x, y) com o giro do antebraço (`deg`).
* `scale` = escala do desenho de 120×120. `layer`: com objeto, "back" = atrás dele e "front" = na frente.
*/
function Hand({ x, y, deg, s, skin, curl, point, gesture, scale = 1, uid, light = 1, layer = "all", thumbFront, onFace }: {
x: number; y: number; deg: number; s: number; skin: string; curl: number; point?: boolean; gesture?: "thumbs_up";
scale?: number; uid: string; light?: number; layer?: "all" | "back" | "front";
/** Pegada de borda (objeto largo, em par): dedos atrás do objeto e só o polegar por cima dele. */
thumbFront?: boolean;
/** Mão apoiada no rosto (queixo, boca, testa). */
onFace?: boolean;
}) {
const raised = Math.cos((deg * Math.PI) / 180) < -0.2;
// Joinha só com o antebraço perto do ângulo para o qual o desenho foi feito (subindo na diagonal); fora disso,
// o polegar apontaria para o lado: vira punho fechado.
const thumbOk = Math.abs(((deg - 135 * (s >= 0 ? 1 : -1) + 540) % 360) - 180) <= 70;
const shape: HandShape = gesture === "thumbs_up" ? (thumbOk ? "thumbs_up" : "fist") : point ? "point" : thumbFront ? (raised ? "pinch_low" : "pinch_edge")
: curl >= 0.6 ? "grip" : onFace ? "on_face" : raised ? "open" : "relaxed";
return <HandArt shape={shape} x={x} y={y} foreDeg={deg} s={s} k={scale} skin={skin} light={light} layer={layer} uid={uid} />;
}
/**
* Fim da manga: barra (punho) com espessura e dobra, a abertura escura por dentro e o pulso saindo DE DENTRO dela,
* com a sombra da manga caindo sobre a pele. Eixo local: (x, y) = borda da manga, +y = para fora (para a mão).
* `w` = largura da manga na borda. Sem `cuff` (manga curta), a barra fica no tom escuro do pano.
*/
export function SleeveEnd({ x, y, deg, w, cloth, cuff, skin, wrist, light, uid, scale = 1, part = "all" }: {
x: number; y: number; deg: number; w: number; cloth: string; cuff?: string; skin: string; wrist: number; light: number; uid: string; scale?: number;
/** "back" = abertura escura (e o pulso, se `wrist` > 0), antes da mão; "front" = sombra no pulso e barra, depois. */
part?: "all" | "back" | "front";
}) {
const up = Math.cos((deg * Math.PI) / 180) >= 0;
const band = cuff ?? shade(cloth, 0.86);
const h = cuff ? 7.5 : 5;
return (
<g transform={`translate(${x} ${y}) rotate(${deg}) scale(${scale})`}>
{/* Abertura da manga (o escuro de dentro) e o pulso saindo dela. */}
{part !== "front" && <>
<ellipse cx={0} cy={0} rx={w * 0.5} ry={w * 0.17} fill={shade(cloth, 0.32)} />
{wrist > 0 && <rect x={-wrist / 2} y={-1.5} width={wrist} height={7} fill={skin} />}
</>}
{part !== "back" && <>
{/* Sombra da manga caindo no pulso e a barra do punho por cima da sobra do pulso. */}
<path d={`M${-8.6} -1.5 L${8.6} -1.5 L${8.6} 2.2 Q0 4.4 ${-8.6} 2.2 Z`} fill={cool(skin, 0.72)} opacity={0.9} />
<Cel id={`cf${uid}`} d={`M${-w / 2} ${-h} L${w / 2} ${-h} Q${w / 2 + 1} 0 ${w / 2} 0.6 Q0 2.4 ${-w / 2} 0.6 Q${-w / 2 - 1} 0 ${-w / 2} ${-h} Z`}
fill={band} side={up ? light : -light} dx={w * 0.22} dy={0} k={0.8} />
<path d={`M${-w / 2 + 1.5} ${-h + 2.2} Q0 ${-h + 3.6} ${w / 2 - 1.5} ${-h + 2.2}`} stroke={shade(band, 0.78)} strokeWidth={1.2} fill="none" strokeLinecap="round" />
</>}
</g>
);
}
/**
* Acessórios em camadas: "torso" = parte da roupa (colete, avental), por baixo de qualquer braço; "chest" = sobre o
* peito (toalha, cachecol, gravata, apito, corrente, crachá), entre o braço ao lado do corpo e o braço na frente do
* peito; "drape" = o pano da toalha apoiado no ombro, sempre por cima da raiz do braço daquele lado.
*/
function Accessories({ look, x0, x1, top, bottom, hipY, side, part, uid }: { look: CharacterLook; x0: number; x1: number; top: number; bottom: number; hipY: number; side: number; part: "torso" | "chest" | "drape"; uid: string }) {
const acc = look.accessories ?? [];
const c = look.accessoryColor;
if (part === "drape") return acc.includes("towel") ? <TowelDrape x1={x1} top={top} color={c ?? "#efe8d6"} side={side} uid={uid} /> : null;
if (part === "chest") {
return (
<g>
{acc.includes("tie") && <><path d={`M95 ${top + 6} L105 ${top + 6} L102 ${top + 16} L98 ${top + 16} Z`} fill={c ?? "#2b3a67"} /><path d={`M98 ${top + 16} L102 ${top + 16} L109 ${top + 82} L100 ${top + 94} L91 ${top + 82} Z`} fill={c ?? "#2b3a67"} /><path d={`M100 ${top + 16} L100 ${top + 92}`} stroke={shade(c ?? "#2b3a67", 0.75)} strokeWidth={2} /></>}
{acc.includes("scarf") && <><rect x={78} y={top - 6} width={44} height={18} rx={8} fill={c ?? "#c8443a"} /><rect x={106} y={top + 8} width={13} height={44} rx={5} fill={shade(c ?? "#c8443a", 0.85)} /></>}
{acc.includes("whistle") && <><path d={`M86 ${top + 4} L100 ${top + 54} L114 ${top + 4}`} stroke="#e8463d" strokeWidth={2.8} fill="none" /><rect x={93} y={top + 52} width={16} height={10} rx={4} fill="#c0c4cc" /><rect x={93} y={top + 52} width={16} height={4} rx={2} fill="#ffffff" opacity={0.5} /></>}
{acc.includes("chain") && <path d={`M84 ${top + 4} Q100 ${top + 48} 116 ${top + 4}`} stroke="#d4a63a" strokeWidth={3.5} fill="none" strokeDasharray="4 2" />}
{acc.includes("badge") && <><rect x={x0 + 16} y={top + 28} width={20} height={14} rx={2} fill={c ?? "#d4a63a"} /><rect x={x0 + 19} y={top + 31} width={8} height={8} rx={1} fill="#ffffff" opacity={0.6} /></>}
{acc.includes("towel") && <TowelBody x1={x1} top={top} hipY={hipY} color={c ?? "#efe8d6"} side={side} uid={uid} />}
</g>
);
}
return (
<g>
{acc.includes("vest") && <>
<path d={`M${x0 + 4} ${top + 12} L${x0 + 32} ${top + 6} L${x0 + 30} ${bottom} L${x0 + 6} ${bottom} Z`} fill={c ?? "#ff8a2a"} />
<path d={`M${x1 - 4} ${top + 12} L${x1 - 32} ${top + 6} L${x1 - 30} ${bottom} L${x1 - 6} ${bottom} Z`} fill={shade(c ?? "#ff8a2a", side > 0 ? 0.82 : 1)} />
<rect x={x0 + 4} y={hipY - 66} width={28} height={9} fill="#e3e6ea" /><rect x={x1 - 32} y={hipY - 66} width={28} height={9} fill="#cfd3d8" />
<rect x={x0 + 4} y={hipY - 36} width={28} height={9} fill="#e3e6ea" /><rect x={x1 - 32} y={hipY - 36} width={28} height={9} fill="#cfd3d8" />
</>}
{acc.includes("apron") && <path d={`M${x0 + 14} ${top + 34} L${x1 - 14} ${top + 34} L${x1 - 6} ${hipY + 70} L${x0 + 6} ${hipY + 70} Z`} fill={c ?? "#eceae3"} />}
</g>
);
}
/**
* Toalha no ombro, parte de baixo: pano largo caindo pela frente do peito, com volume (sombra cel), dobras, listras
* e franja na ponta, e a sombra que ela faz no casaco.
*/
function TowelBody({ x1, top, hipY, color, side, uid }: { x1: number; top: number; hipY: number; color: string; side: number; uid: string }) {
const end = hipY - 18;
const d = `M${x1 - 47} ${top + 6} C${x1 - 44} ${top + 40} ${x1 - 49} ${end - 30} ${x1 - 47} ${end} L${x1 - 9} ${end + 4} C${x1 - 8} ${end - 30} ${x1 - 4} ${top + 40} ${x1 - 6} ${top + 10} Z`;
const stripe = shade(color, 0.72);
return (
<g>
{/* Sombra do pano no casaco (lado de dentro). */}
<path d={`M${x1 - 47} ${top + 10} C${x1 - 44} ${top + 40} ${x1 - 49} ${end - 30} ${x1 - 47} ${end} L${x1 - 53} ${end - 2} C${x1 - 54} ${end - 30} ${x1 - 50} ${top + 40} ${x1 - 52} ${top + 12} Z`} fill="#000000" opacity={0.16} />
<Cel id={`tw${uid}`} d={d} fill={color} side={side} dx={9} dy={0} k={0.82} />
{/* Dobras verticais do pano. */}
<path d={`M${x1 - 33} ${top + 16} C${x1 - 31} ${top + 50} ${x1 - 35} ${end - 30} ${x1 - 33} ${end - 6} M${x1 - 20} ${top + 18} C${x1 - 18} ${top + 52} ${x1 - 22} ${end - 30} ${x1 - 20} ${end - 4}`} stroke={shade(color, 0.86)} strokeWidth={2.4} fill="none" strokeLinecap="round" />
{/* Duas listras perto da ponta e a franja. */}
<path d={`M${x1 - 47.5} ${end - 22} L${x1 - 8.5} ${end - 18} M${x1 - 47.5} ${end - 13} L${x1 - 8.5} ${end - 9}`} stroke={stripe} strokeWidth={3.2} />
<path d={Array.from({ length: 7 }, (_, i) => { const x = x1 - 45 + i * 5.6; const y = end + 0.6 + i * 0.6; return `M${x} ${y} L${x - 0.6} ${y + 5}`; }).join(" ")} stroke={shade(color, 0.8)} strokeWidth={2} strokeLinecap="round" />
</g>
);
}
/** Toalha no ombro, parte de cima: a dobra arredondada sobre o ombro, por cima da raiz do braço. */
function TowelDrape({ x1, top, color, side, uid }: { x1: number; top: number; color: string; side: number; uid: string }) {
// Pano dobrado deitado sobre o ombro (segue a linha do ombro, não sobe no pescoço) e caindo um pouco para trás.
const d = `M${x1 - 48} ${top + 10} C${x1 - 44} ${top - 4} ${x1 - 16} ${top - 9} ${x1 + 4} ${top - 4} C${x1 + 14} ${top} ${x1 + 17} ${top + 12} ${x1 + 13} ${top + 24}`
+ ` C${x1 + 9} ${top + 29} ${x1 + 2} ${top + 27} ${x1} ${top + 20} C${x1 - 6} ${top + 8} ${x1 - 28} ${top + 6} ${x1 - 48} ${top + 16} Z`;
return (
<g>
<Cel id={`td${uid}`} d={d} fill={shade(color, 1.03)} side={side} dx={6} dy={-2} k={0.8} />
{/* Dobra do pano por cima do ombro e a borda de baixo que cai para trás. */}
<path d={`M${x1 - 40} ${top + 7} C${x1 - 28} ${top - 1} ${x1 - 8} ${top - 3} ${x1 + 6} ${top + 5}`} stroke={shade(color, 0.84)} strokeWidth={2} fill="none" strokeLinecap="round" />
<path d={`M${x1 + 13} ${top + 24} C${x1 + 9} ${top + 29} ${x1 + 2} ${top + 27} ${x1} ${top + 20}`} stroke={shade(color, 0.7)} strokeWidth={2} fill="none" strokeLinecap="round" />
</g>
);
}
export function CharacterFigure({ look = DEFAULT_LOOK, expression, pose, item, t = 0, state, shadeSide = 1, gesture }: {
look?: CharacterLook; expression?: string; pose?: string; item?: IconId; t?: number;
/** Gesto da mão direita quando ela não segura nem aponta ("thumbs_up" = polegar para cima). */
gesture?: "thumbs_up";
/** Estado calculado pela linha do tempo (motion.ts). Sem ele: expressão/pose pedidas + piscar/respirar. */
state?: Pick<ActorState, "face" | "body" | "emote">;
/** Lado da sombra no desenho (1 = direita, -1 = esquerda). Quem espelha o personagem inverte para a luz ficar
* do mesmo lado da cena. */
shadeSide?: 1 | -1;
}) {
const uid = useId().replace(/:/g, "");
const st = state ?? evaluate({ x: 0, expression, pose }, t, 3600, 1);
const f = st.face;
// Objeto largo (livro, tábua) vai nas DUAS mãos: os dois braços vão para a pose de segurar pelas bordas.
const twoHanded = !!item && TWO_HANDED.includes(item) && (st.body.armR.raise > 20 || st.body.armR.bend > 40);
const b: BodyParams = twoHanded ? { ...st.body, armL: { ...POSE_PRESETS.hold_both.arms }, armR: { ...POSE_PRESETS.hold_both.arms } } : st.body;
const gest = gesture ?? (pose === "thumbs_up" ? "thumbs_up" : undefined);
/** Escala do desenho da mão (quadro 120×120): mão ≈ do nariz ao queixo. */
const HAND_K = 0.62;
const side = shadeSide;
const w = look.build === "slim" ? 0.86 : look.build === "heavy" ? 1.2 : 1;
const breathe = Math.sin(t * 2.2) * 1.4;
const top = look.top;
// Quadril desce ao sentar; coxas abrem e encurtam (perspectiva), canelas voltam para baixo.
const hipY = 306 + b.crouch * 56;
const legW = 30 * w;
const longTop = top.style === "dress" || top.style === "robe";
const pants = longTop || look.bottom.style !== "pants" ? look.skin : look.bottom.color;
const footwear = look.footwear ?? "shoes";
const thighLen = 62 * (1 - 0.72 * b.crouch);
const leg = (s: 1 | -1, l: Limb) => {
const hx = 100 + s * 24 * w;
const thighDeg = -s * (l.raise + b.crouch * 55);
const knee = tip(hx, hipY, thighDeg, thighLen);
const shinDeg = thighDeg + s * (l.bend + b.crouch * 55);
const foot = tip(knee.x, knee.y, shinDeg, 58);
const shorts = look.bottom.style === "shorts" && !longTop;
const fw = legW + 14;
const fy = foot.y + 2;
return (
<g key={s}>
<Limb2 id={`th${uid}${s}`} x={hx} y={hipY} deg={thighDeg} len={thighLen} w1={legW + 4} w2={legW * 0.92} fill={shorts ? look.bottom.color : pants} side={side} />
<Limb2 id={`sh${uid}${s}`} x={knee.x} y={knee.y} deg={shinDeg} len={58} w1={legW * 0.92} w2={legW * 0.78} fill={pants} side={side} />
{/* Barra da calça. */}
{pants !== look.skin && <rect x={foot.x - legW * 0.48} y={foot.y - 9} width={legW * 0.96} height={6} rx={3} fill={shade(pants, 0.8)} />}
{footwear === "shoes" && <>
<path d={`M${foot.x - fw / 2} ${fy + 6} Q${foot.x - fw / 2} ${fy - 12} ${foot.x} ${fy - 12} Q${foot.x + fw / 2} ${fy - 12} ${foot.x + fw / 2} ${fy + 6} Z`} fill={look.shoes} />
<rect x={foot.x - fw / 2 - 1} y={fy + 3} width={fw + 2} height={6} rx={3} fill={shade(look.shoes, look.shoes === "#f2f2f2" ? 0.8 : 0.6)} />
<ellipse cx={foot.x - side * 4} cy={fy - 6} rx={fw * 0.2} ry={3} fill="#ffffff" opacity={0.22} />
</>}
{footwear !== "shoes" && <path d={`M${foot.x - fw / 2 + 3} ${fy + 6} Q${foot.x - fw / 2 + 3} ${fy - 10} ${foot.x} ${fy - 10} Q${foot.x + fw / 2 - 3} ${fy - 10} ${foot.x + fw / 2 - 3} ${fy + 6} Z`} fill={shade(look.skin, 0.95)} />}
{/* Sandália: sola fina e duas tiras cruzando o peito do pé. */}
{footwear === "sandals" && <>
<rect x={foot.x - fw / 2 + 1} y={fy + 3} width={fw - 2} height={6} rx={3} fill={look.shoes} />
<path d={`M${foot.x - fw / 2 + 6} ${fy - 6} L${foot.x + fw / 2 - 6} ${fy + 3} M${foot.x + fw / 2 - 6} ${fy - 6} L${foot.x - fw / 2 + 6} ${fy + 3}`} stroke={look.shoes} strokeWidth={3.6} strokeLinecap="round" />
</>}
</g>
);
};
const shY = hipY - 100;
const torsoTop = hipY - 114;
const longSleeve = ["jacket", "hoodie", "uniform", "robe"].includes(top.style);
const sleeve = top.style === "dress" ? look.skin : top.color;
const holdItem = !twoHanded && (b.armR.raise > 20 || b.armR.bend > 40) ? item : undefined;
const arm = (s: 1 | -1, l: Limb, holds?: IconId, part: "all" | "upper" | "lower" = "all") => {
const x = 100 + s * 54 * w;
const upperDeg = -s * l.raise;
const elbow = tip(x, shY, upperDeg, 56);
const foreDeg = upperDeg + s * l.bend;
// Aponta com o braço esticado para a frente (point, reach); erguido acima da cabeça (wave, arms_up) a mão fica aberta.
const pointing = !holds && s > 0 && l.raise > 60 && l.raise < 125 && Math.abs(l.bend) < 30;
// Manga longa termina numa borda (punho) e o pulso sai de dentro dela; manga curta: o braço segue em pele até a
// mão. A mão nasce do pulso, com a mesma pele e a mesma luz do rosto.
const HAND = HAND_K;
const cuffL = 40;
const wristL = longSleeve ? 43 : 41;
const wrist = tip(elbow.x, elbow.y, foreDeg, wristL);
// Objeto de uma mão: o cabo passa por dentro do punho (ponto `hold` da forma "grip"), em pé.
const gp = handPlacement("grip", wrist.x, wrist.y, foreDeg, s, HAND);
const gi = holds ? (GRIP[holds] ?? { x: 50, y: 60, rot: 0 }) : null;
const cuffEnd = tip(elbow.x, elbow.y, foreDeg, cuffL);
const bareArm = !longSleeve;
// Borda de dentro do braço no tom escuro do pano: separa o braço caído do tronco da mesma cor.
const innerEdge = (px: number, py: number, d: number, len: number, w1: number, w2: number, color: string) => {
const ix = Math.cos((d * Math.PI) / 180) >= 0 ? -s : s;
return <path d={`M${(ix * w1) / 2} 3 L${(ix * w2) / 2} ${len - 2}`} transform={`translate(${px} ${py}) rotate(${d})`} stroke={shade(color, 0.55)} strokeWidth={2.4} strokeLinecap="round" opacity={0.85} />;
};
const hand = { x: wrist.x, y: wrist.y, deg: foreDeg, s, skin: look.skin, light: side, scale: HAND, uid: `${uid}${s}`, onFace: (s > 0 ? layerR : layerL) === "face" };
// Parte de cima (braço e manga curta) e de baixo (antebraço, punho, mão e objeto) podem ir em camadas diferentes:
// o antebraço que cruza o peito passa por cima do pano no ombro, a raiz do braço fica por baixo dele.
const up = part !== "lower";
const low = part !== "upper";
return (
<g key={`${s}${part}`}>
{up && <>
<Limb2 id={`ua${uid}${s}`} x={x} y={shY} deg={upperDeg} len={56} w1={33 * Math.max(0.9, w * 0.95)} w2={26} fill={bareArm && top.style !== "dress" ? look.skin : sleeve} side={side} />
{!bareArm && innerEdge(x, shY, upperDeg, 56, 33 * Math.max(0.9, w * 0.95), 26, sleeve)}
{!longSleeve && top.style !== "dress" && <>
{/* Manga curta com a ponta reta (borda de pano), não arredondada: o braço sai de dentro dela. */}
<Cel id={`sl${uid}${s}`} d="M-18.5 0 L-16.2 34 Q0 35.6 16.2 34 L18.5 0 A18.5 18.5 0 0 0 -18.5 0 Z" fill={sleeve}
side={Math.cos((upperDeg * Math.PI) / 180) >= 0 ? side : -side} dx={11} dy={0} transform={`translate(${x} ${shY - 2}) rotate(${upperDeg})`} />
{innerEdge(x, shY - 2, upperDeg, 34, 37, 32.4, sleeve)}
{(() => { const e = tip(x, shY - 2, upperDeg, 34.4); return <SleeveEnd x={e.x} y={e.y} deg={upperDeg} w={32.6} cloth={sleeve} skin={look.skin} wrist={28} light={side} uid={`${uid}s${s}`} />; })()}
</>}
</>}
{low && <>
{longSleeve
? <Limb2 id={`fa${uid}${s}`} x={elbow.x} y={elbow.y} deg={foreDeg} len={cuffL - 11} w1={25} w2={23} fill={sleeve} side={side} />
: <Limb2 id={`fa${uid}${s}`} x={elbow.x} y={elbow.y} deg={foreDeg} len={wristL + 4} w1={22} w2={17} fill={look.skin} side={side} />}
{longSleeve && innerEdge(elbow.x, elbow.y, foreDeg, cuffL - 6, 25, 23, sleeve)}
{/* Dobra no cotovelo e punho da manga. */}
{longSleeve && <path d={`M${elbow.x - 7} ${elbow.y - 3} Q${elbow.x} ${elbow.y + 3} ${elbow.x + 7} ${elbow.y - 3}`} stroke={shade(sleeve, 0.72)} strokeWidth={2.4} fill="none" strokeLinecap="round" transform={`rotate(${foreDeg} ${elbow.x} ${elbow.y})`} />}
{/* Punho da manga com espessura e a abertura escura; o pulso sai de dentro, com a sombra da manga por cima. */}
{longSleeve && <SleeveEnd x={cuffEnd.x} y={cuffEnd.y} deg={foreDeg} w={25.5} cloth={sleeve} skin={look.skin} wrist={0} light={side} uid={`${uid}${s}`} part="back" />}
{s < 0 && look.accessories?.includes("watch") && (() => { const c = tip(elbow.x, elbow.y, foreDeg, wristL + 1); return <rect x={c.x - 10} y={c.y - 4.5} width={20} height={8} rx={3} fill="#d4a63a" transform={`rotate(${foreDeg} ${c.x} ${c.y})`} />; })()}
{/* Segurando: dorso atrás do objeto, dedos dobrados e polegar por cima dele. */}
{holds && gi && gp.hold && (
<g transform={`translate(${gp.hold.x} ${gp.hold.y}) rotate(${gp.rot + gi.rot}) scale(0.88) translate(${-gi.x} ${-gi.y})`}>
<svg width={100} height={100} viewBox="0 0 100 100" overflow="visible"><Icon id={holds} /></svg>
</g>
)}
{/* Duas mãos num objeto largo: aqui só a parte de trás (dedos atrás do objeto); objeto e polegares depois. */}
{twoHanded && <Hand {...hand} curl={1} thumbFront layer="back" />}
{!twoHanded && <Hand {...hand} curl={holds ? 1 : 0.35} point={pointing} gesture={s > 0 && !holds && !pointing ? gest : undefined} layer={holds ? "front" : "all"} />}
{longSleeve && <SleeveEnd x={cuffEnd.x} y={cuffEnd.y} deg={foreDeg} w={25.5} cloth={sleeve} skin={look.skin} wrist={17} light={side} uid={`${uid}${s}`} part="front"
cuff={top.style === "uniform" || top.style === "jacket" ? (top.accent ?? shade(sleeve, 0.8)) : undefined} />}
</>}
</g>
);
};
// Profundidade de cada braço pelo estado do rig (limbs.ts): ao lado do corpo, na frente do peito ou no rosto.
// Com o personagem de frente, braço e mão nunca somem atrás do tronco, de acessório ou da barba.
const layerL = armLayer(b, -1, { w, holds: twoHanded });
const layerR = armLayer(b, 1, { w, holds: !!holdItem || twoHanded });
// Objeto largo: entre as duas pegadas de borda, na frente do tronco; os polegares por cima dele.
const twoHand = () => {
if (!twoHanded || !item) return null;
const grab = (s: 1 | -1) => {
const l = s > 0 ? b.armR : b.armL;
const upperDeg = -s * l.raise;
const elbow = tip(100 + s * 54 * w, shY, upperDeg, 56);
const foreDeg = upperDeg + s * l.bend;
const wrist = tip(elbow.x, elbow.y, foreDeg, longSleeve ? 43 : 41);
return { s, wrist, foreDeg, hold: handPlacement("pinch_edge", wrist.x, wrist.y, foreDeg, s, HAND_K).hold! };
};
const [L, R] = [grab(-1), grab(1)];
// Borda do desenho do ícone (fração da largura): o livro vai de 8 a 92, a tábua de 14 a 86.
const span = item === "tablet" ? 0.72 : 0.84;
const size = Math.abs(R.hold.x - L.hold.x) / span;
const cx = (L.hold.x + R.hold.x) / 2;
const cy = (L.hold.y + R.hold.y) / 2;
return <>
<svg x={cx - size / 2} y={cy - size * 0.56} width={size} height={size} viewBox="0 0 100 100" overflow="visible"><Icon id={item} /></svg>
{[L, R].map((g) => <Hand key={g.s} x={g.wrist.x} y={g.wrist.y} deg={g.foreDeg} s={g.s} skin={look.skin} light={side} scale={HAND_K} uid={`${uid}${g.s}`} curl={1} thumbFront layer="front" />)}
</>;
};
// Braço "side" inteiro na camada dele; braço "front"/"face": a raiz junto com os de lado (por baixo do pano do
// ombro) e o antebraço/mão na camada própria (por cima do pano, do peito ou do rosto).
const arms = (layer: string) => <>
{layer === "side" && <>
{layerL === "side" ? arm(-1, b.armL) : arm(-1, b.armL, undefined, "upper")}
{layerR === "side" ? arm(1, b.armR, holdItem) : arm(1, b.armR, undefined, "upper")}
</>}
{layer !== "side" && layerL === layer && arm(-1, b.armL, undefined, "lower")}
{layer !== "side" && layerR === layer && arm(1, b.armR, layer === "face" ? undefined : holdItem, "lower")}
</>;
const x0 = 100 - 56 * w;
const x1 = 100 + 56 * w;
const torsoBottom = top.style === "dress" ? hipY + 58 : top.style === "robe" ? hipY + 108 - b.crouch * 40 : hipY + 6;
const flare = top.style === "dress" ? 16 : top.style === "robe" ? 20 : 0;
const accent = top.accent ?? shade(top.color, 1.3);
const bulge = look.belly ? 14 : look.build === "heavy" ? 8 : 2;
// Tronco em "pera": ombros redondos, cintura e barriga mais largas embaixo.
const torsoPath = `M${100 - 36 * w} ${torsoTop} C${x0 - 6} ${torsoTop + 2} ${x0 - 8} ${torsoTop + 34} ${x0 - 2} ${torsoTop + 62}`
+ ` C${x0 - bulge} ${torsoTop + 88} ${x0 - flare - bulge * 0.6} ${torsoBottom - 10} ${x0 - flare + 2} ${torsoBottom}`
+ ` L${x1 + flare - 2} ${torsoBottom} C${x1 + flare + bulge * 0.6} ${torsoBottom - 10} ${x1 + bulge} ${torsoTop + 88} ${x1 + 2} ${torsoTop + 62}`
+ ` C${x1 + 8} ${torsoTop + 34} ${x1 + 6} ${torsoTop + 2} ${100 + 36 * w} ${torsoTop} Z`;
const fold = shade(top.color, 0.74);
const neckH = 28;
// Largura do pescoço proporcional à cabeça (≈ metade dela), um pouco mais grosso em corpo forte.
const nw = 26 * (HEAD_SCALE / 1.2) * (look.build === "heavy" ? 1.12 : look.build === "slim" ? 0.92 : 1);
const headTransform = `translate(0 ${torsoTop - neckH + 6 + breathe * 0.4}) rotate(${b.headTilt} 100 0) translate(100 0) scale(${HEAD_SCALE}) translate(-100 -156)`;
return ( return (
<svg viewBox="0 0 200 440" width="100%" height="100%" overflow="visible"> <svg viewBox="0 0 200 440" width="100%" height="100%" overflow="visible">
<g transform={`translate(100 440) scale(${look.height}) translate(-100 -440) translate(0 ${breathe * 0.3})`}> <g transform={`translate(100 440) scale(${look.height}) translate(-100 -440)`}>
<HairBack look={look} /> {/* Sombra de contato no chão. */}
<Legs look={look} w={w} /> <ellipse cx={100} cy={438} rx={66 * w} ry={8} fill="#000000" opacity={0.18} />
{arm(-1, lAngle)} {look.hair.style === "long" && (
<Torso look={look} w={w} /> <g transform={`rotate(${b.lean} 100 ${hipY})`}>
{pose !== "think" && arm(1, rAngle, pose === "hold" || pose === "point" ? item : undefined)} <g transform={headTransform}>
<rect x={90} y={146} width={20} height={16} fill={shade(look.skin, 0.9)} /> <Cel id={`hb${uid}`} d="M50 104 Q46 46 100 46 Q154 46 150 104 L158 214 Q100 232 42 214 Z" fill={shade(look.hair.color, 0.9)} side={side} dx={10} dy={0} />
<g transform={`translate(0 ${breathe * 0.4})`}> </g>
<ellipse cx={53} cy={112} rx={8} ry={11} fill={shade(look.skin, 0.92)} /> </g>
<ellipse cx={147} cy={112} rx={8} ry={11} fill={shade(look.skin, 0.92)} /> )}
<ellipse cx={100} cy={106} rx={47} ry={50} fill={look.skin} /> {leg(-1, b.legL)}
<Beard style={look.beard.style} color={look.beard.color} /> {leg(1, b.legR)}
<Eyes expression={expression} t={t} /> {look.bottom.style === "skirt" && !longTop && (
<Brows expression={expression} thick={look.brows === "thick"} color={look.hair.style === "bald" || look.hair.style === "cap" ? look.beard.color : look.hair.color} /> <path d={`M${100 - 34 * w} ${hipY - 6} L${100 + 34 * w} ${hipY - 6} L${100 + 46 * w} ${hipY + 52} L${100 - 46 * w} ${hipY + 52} Z`} fill={look.bottom.color} />
<Glasses kind={look.glasses} /> )}
<Mouth expression={expression} /> {!longTop && <path d={`M${100 - 40 * w} ${hipY - 4} L${100 + 40 * w} ${hipY - 4} L${100 + 38 * w} ${hipY + 16} L${100 - 38 * w} ${hipY + 16} Z`} fill={look.bottom.style === "pants" ? look.bottom.color : look.bottom.color} />}
<HairFront look={look} /> <g transform={`rotate(${b.lean} 100 ${hipY}) translate(0 ${breathe * 0.3})`}>
<g>
{top.style === "hoodie" && <path d={`M${x0 + 4} ${torsoTop + 8} Q100 ${torsoTop - 30} ${x1 - 4} ${torsoTop + 8} Z`} fill={shade(top.color, 0.78)} />}
{/* Pescoço com a sombra do queixo. */}
{/* Pescoço visível: alarga na base (trapézio), sombra do queixo em cima e o lado da sombra mais escuro. */}
<path d={`M${100 - nw} ${torsoTop - neckH - 8} L${100 + nw} ${torsoTop - neckH - 8} L${100 + nw + 6} ${torsoTop + 10} L${100 - nw - 6} ${torsoTop + 10} Z`} fill={look.skin} />
<path d={`M${100 + side * 4} ${torsoTop - neckH - 8} L${100 + side * nw} ${torsoTop - neckH - 8} L${100 + side * (nw + 6)} ${torsoTop + 10} L${100 + side * 8} ${torsoTop + 10} Z`} fill={cool(look.skin, 0.84)} />
<path d={`M${100 - nw} ${torsoTop - neckH - 8} L${100 + nw} ${torsoTop - neckH - 8} L${100 + nw + 0.5} ${torsoTop - neckH + 6} Q100 ${torsoTop - neckH + 12} ${100 - nw - 0.5} ${torsoTop - neckH + 6} Z`} fill={cool(look.skin, 0.74)} />
<path d={`M${100 - 6} ${torsoTop - 4} Q100 ${torsoTop + 2} ${100 + 6} ${torsoTop - 4}`} stroke={shade(look.skin, 0.72)} strokeWidth={2} fill="none" strokeLinecap="round" />
<Cel id={`to${uid}`} d={torsoPath} fill={top.color} side={side} dx={16} dy={-4} k={0.8} />
{/* Barra / cós embaixo do tronco. */}
{!longTop && <path d={`M${x0 - 1} ${torsoBottom - 9} L${x1 + 1} ${torsoBottom - 9} L${x1 + 1} ${torsoBottom} L${x0 - 1} ${torsoBottom} Z`} fill={shade(top.color, 0.82)} />}
{/* Dobras do tecido: axilas, barriga. */}
<path d={`M${x0 + 8} ${torsoTop + 46} Q${x0 + 18} ${torsoTop + 58} ${x0 + 14} ${torsoTop + 72} M${x1 - 8} ${torsoTop + 46} Q${x1 - 18} ${torsoTop + 58} ${x1 - 14} ${torsoTop + 72}`} stroke={fold} strokeWidth={2.6} fill="none" strokeLinecap="round" />
{(look.belly || look.build === "heavy") && <path d={`M${100 - 30 * w} ${hipY - 16} Q100 ${hipY + 2} ${100 + 30 * w} ${hipY - 16}`} stroke={fold} strokeWidth={3} fill="none" strokeLinecap="round" />}
<path d={`M${100 - 18 * w} ${hipY - 34} Q${100 - 8} ${hipY - 28} ${100 - 4} ${hipY - 36}`} stroke={fold} strokeWidth={2.2} fill="none" strokeLinecap="round" opacity={0.7} />
{/* Construção da roupa por estilo. */}
{top.style === "shirt" && <>
<path d={`M84 ${torsoTop - 2} L100 ${torsoTop + 20} L94 ${torsoTop + 2} Z M116 ${torsoTop - 2} L100 ${torsoTop + 20} L106 ${torsoTop + 2} Z`} fill={shade(top.color, 1.15)} />
<path d={`M100 ${torsoTop + 20} L100 ${torsoBottom - 10}`} stroke={fold} strokeWidth={2} />
{[0, 1, 2].map((i) => <circle key={i} cx={103} cy={torsoTop + 34 + i * 24} r={2.6} fill={shade(top.color, 0.65)} />)}
{top.accent && <rect x={x0 - 4} y={hipY - 40} width={x1 - x0 + 8} height={9} fill={accent} />}
</>}
{top.style === "uniform" && <>
<path d={`M84 ${torsoTop - 2} L100 ${torsoTop + 16} L116 ${torsoTop - 2} L110 ${torsoTop + 6} L100 ${torsoTop + 12} L90 ${torsoTop + 6} Z`} fill={shade(top.color, 0.7)} />
<path d={`M100 ${torsoTop + 14} L100 ${torsoBottom - 10}`} stroke={fold} strokeWidth={2.4} />
{[0, 1, 2, 3].map((i) => <circle key={i} cx={103} cy={torsoTop + 28 + i * 20} r={2.6} fill={accent} />)}
<rect x={x0 + 12} y={torsoTop + 28} width={24} height={16} rx={3} fill={shade(top.color, 0.86)} />
<rect x={x0 - 4} y={hipY - 44} width={x1 - x0 + 8} height={10} fill={accent} />
</>}
{(top.style === "jacket" || top.style === "hoodie") && <>
{/* Camiseta clara por baixo, zíper com puxador, gola. */}
<path d={`M88 ${torsoTop} L100 ${torsoTop + 28} L112 ${torsoTop} Z`} fill={top.style === "jacket" ? "#efeae0" : shade(top.color, 0.8)} />
<path d={`M100 ${torsoTop + 26} L100 ${torsoBottom - 4}`} stroke={shade(top.color, 0.58)} strokeWidth={3.4} />
<rect x={97} y={torsoTop + 40} width={6} height={11} rx={2} fill={shade(top.color, 1.35)} />
{top.style === "jacket" && <>
<path d={`M80 ${torsoTop - 4} L100 ${torsoTop + 28} L92 ${torsoTop - 2} Z M120 ${torsoTop - 4} L100 ${torsoTop + 28} L108 ${torsoTop - 2} Z`} fill={accent} />
<path d={`M${x0 + 2} ${torsoTop + 58} L${x0 + 2} ${torsoBottom - 10} M${x1 - 2} ${torsoTop + 58} L${x1 - 2} ${torsoBottom - 10}`} stroke={accent} strokeWidth={5} />
</>}
{top.style === "hoodie" && <>
<rect x={80} y={hipY - 52} width={40} height={24} rx={7} fill={shade(top.color, 0.86)} />
<path d={`M93 ${torsoTop + 4} L91 ${torsoTop + 34} M107 ${torsoTop + 4} L109 ${torsoTop + 34}`} stroke="#efeae0" strokeWidth={2.4} strokeLinecap="round" />
</>}
</>}
{top.style === "dress" && <>
<path d={`M86 ${torsoTop} Q100 ${torsoTop + 20} 114 ${torsoTop}`} stroke={shade(top.color, 0.7)} strokeWidth={4} fill="none" />
{[0, 1, 2, 3, 4, 5].map((i) => <circle key={i} cx={78 + (i % 3) * 22} cy={torsoTop + 44 + Math.floor(i / 3) * 70} r={3.5} fill="#ffffff" opacity={0.45} />)}
<path d={`M${x0 - flare + 4} ${torsoBottom - 4} L${x1 + flare - 4} ${torsoBottom - 4}`} stroke={shade(top.color, 0.78)} strokeWidth={6} />
</>}
{top.style === "robe" && <>
{/* Gola em V, dobras do pano e faixa amarrada na cintura com a ponta caindo. */}
<path d={`M84 ${torsoTop} L100 ${torsoTop + 30} L116 ${torsoTop} Z`} fill={shade(top.color, 0.7)} />
<path d={`M${100 - 18 * w} ${hipY + 6} Q${100 - 22 * w} ${hipY + 50} ${100 - 26 * w} ${torsoBottom - 4} M${100 + 12 * w} ${hipY + 8} Q${100 + 16 * w} ${hipY + 50} ${100 + 22 * w} ${torsoBottom - 4} M100 ${hipY + 14} L100 ${torsoBottom - 6}`} stroke={fold} strokeWidth={3} fill="none" strokeLinecap="round" />
<rect x={x0 - 3} y={hipY - 30} width={x1 - x0 + 6} height={13} rx={5} fill={accent} />
<path d={`M${100 + 10 * w} ${hipY - 20} L${100 + 16 * w} ${hipY + 28} L${100 + 25 * w} ${hipY + 26} L${100 + 19 * w} ${hipY - 20} Z`} fill={shade(accent, 0.82)} />
<path d={`M${x0 - flare + 4} ${torsoBottom - 3} L${x1 + flare - 4} ${torsoBottom - 3}`} stroke={shade(top.color, 0.72)} strokeWidth={5} />
</>}
<Accessories look={look} x0={x0} x1={x1} top={torsoTop} bottom={torsoBottom} hipY={hipY} side={side} part="torso" uid={uid} />
</g>
{/* Camadas: braço ao lado do corpo (e a raiz dos outros) → pano do peito → pano no ombro → antebraço/mão na
frente do peito → cabeça → mão no rosto. */}
{arms("side")}
<Accessories look={look} x0={x0} x1={x1} top={torsoTop} bottom={torsoBottom} hipY={hipY} side={side} part="chest" uid={uid} />
<Accessories look={look} x0={x0} x1={x1} top={torsoTop} bottom={torsoBottom} hipY={hipY} side={side} part="drape" uid={uid} />
{arms("front")}
{twoHand()}
<g transform={headTransform}>
<Head look={look} f={f} b={b} t={t} uid={uid} side={side} />
{st.emote && (
<g transform={`translate(156 40) scale(${0.4 + 0.6 * st.emote.k})`} opacity={st.emote.k}>
<circle r={22} fill="#ffffff" />
<text y={10} textAnchor="middle" fontSize={28} fontWeight={800} fill={st.emote.text === "!" || st.emote.text === "💢" ? "#e8463d" : INK}>{st.emote.text}</text>
</g>
)}
</g>
{arms("face")}
</g> </g>
{/* Pensando: a mão vai ao queixo, por cima da barba. */}
{pose === "think" && arm(1, rAngle)}
</g> </g>
</svg> </svg>
); );
} }
/**
* Vista "insert": close das MÃOS fazendo algo (segurando o objeto, escrevendo), antebraços entrando por baixo
* com a manga da roupa do personagem. Ocupa a área inteira de quem desenha (viewBox 1080×1080).
*/
export function HandsInsert({ look = DEFAULT_LOOK, item, t = 0, shadeSide = 1 }: { look?: CharacterLook; item?: IconId; t?: number; shadeSide?: 1 | -1 }) {
const uid = useId().replace(/:/g, "");
const sway = Math.sin(t * 1.6) * 6;
const long = ["jacket", "hoodie", "uniform", "robe"].includes(look.top.style);
const cloth = look.top.style === "dress" ? look.skin : look.top.color;
const cuff = look.top.style === "uniform" || look.top.style === "jacket" ? (look.top.accent ?? shade(cloth, 0.8)) : undefined;
// Mão grande (close): a mesma biblioteca de mãos em escala; a manga/punho na mesma proporção do braço.
const K = 2.7;
const S = 5;
const cy = 560 + sway * 0.5;
const arms = ([-1, 1] as const).map((s) => {
// O antebraço sobe do canto de baixo, inclinado para dentro; no pulso a mão dobra: os dedos ficam ATRÁS da
// borda lateral do objeto e o polegar comprido apoia por cima da página (pegada de quem segura um livro aberto).
const deg = 180 - s * 30;
const edge = { x: 540 + s * 250 + (s > 0 ? sway : 0), y: 660 + (s > 0 ? -sway : 0) };
// Pegada de borda com o antebraço vindo de baixo: o pulso segue o eixo do antebraço até a mão.
const wrist = item ? wristForHold("pinch_low", edge.x, edge.y, deg, s, K) : { x: edge.x + s * 40, y: edge.y + 120 };
const end = tip(wrist.x, wrist.y, deg, -3 * S);
const start = tip(end.x, end.y, deg, -560);
const hand = { x: wrist.x, y: wrist.y, deg, s, skin: look.skin, light: shadeSide, scale: K, uid: `${uid}i${s}` };
return { s, deg, wrist, end, start, hand };
});
return (
<svg viewBox="0 0 1080 1080" width="100%" height="100%" overflow="visible">
{arms.map(({ s, deg, end, start, hand }) => (
<g key={s}>
{long
? <>
<Limb2 id={`if${uid}${s}`} x={start.x} y={start.y} deg={deg} len={560 - 11 * S} w1={34 * S} w2={23 * S} fill={cloth} side={shadeSide} />
{/* Dobras do pano no antebraço. */}
<path d={`M${-9 * S} 300 Q0 ${300 + 4 * S} ${8 * S} 296 M${-7 * S} 420 Q${-1 * S} ${420 + 3 * S} ${7 * S} 418`} stroke={shade(cloth, 0.74)} strokeWidth={2.2 * S} fill="none" strokeLinecap="round" transform={`translate(${start.x} ${start.y}) rotate(${deg})`} />
<SleeveEnd x={end.x} y={end.y} deg={deg} w={25.5} cloth={cloth} cuff={cuff} skin={look.skin} wrist={0} light={shadeSide} uid={`${uid}ie${s}`} scale={S} part="back" />
</>
: <Limb2 id={`if${uid}${s}`} x={start.x} y={start.y} deg={deg} len={560 + 6 * S} w1={26 * S} w2={17 * S} fill={look.skin} side={shadeSide} />}
{item && <Hand {...hand} curl={1} layer="back" thumbFront />}
</g>
))}
{item && <g transform={`translate(540 ${cy})`}><svg x={-300} y={-300} width={600} height={600} viewBox="0 0 100 100" overflow="visible"><Icon id={item} /></svg></g>}
{/* Só o polegar por cima do objeto; sem objeto, as mãos relaxadas inteiras. */}
{arms.map(({ s, hand }) => <Hand key={s} {...hand} curl={item ? 1 : 0.35} layer={item ? "front" : "all"} thumbFront={!!item} />)}
{/* Barra do punho por cima da sobra do pulso. */}
{long && arms.map(({ s, deg, end }) => <SleeveEnd key={`f${s}`} x={end.x} y={end.y} deg={deg} w={25.5} cloth={cloth} cuff={cuff} skin={look.skin} wrist={17} light={shadeSide} uid={`${uid}ie${s}`} scale={S} part="front" />)}
</svg>
);
}
+72 -16
View File
@@ -4,10 +4,12 @@ import React from "react";
import { AbsoluteFill, useCurrentFrame, useVideoConfig } from "remotion"; import { AbsoluteFill, useCurrentFrame, useVideoConfig } from "remotion";
import { CrowdFigure, PersonFigure } from "./actors"; import { CrowdFigure, PersonFigure } from "./actors";
import { Icon } from "./icons"; import { Icon } from "./icons";
import { Captions, CrossOut, Hud, Rings, TagLabel, TextLayer, pop, shake } from "./overlays"; import { Captions, CrossOut, Grain, Hud, Rings, TagLabel, TextLayer, pop, shake } from "./overlays";
import { SceneBackground } from "./scenes"; import { SceneBackground } from "./scenes";
import { CharacterFigure } from "./CharacterFigure"; import { CharacterFigure, HandsInsert } from "./CharacterFigure";
import { LightLayer } from "./places"; import { evaluate } from "./motion";
import { LightLayer, PlaceForeground, WeatherLayer } from "./places";
import { AnimalFigure, BIRDS, SPECIES_HEIGHT } from "./animals";
import type { ShotSpec } from "./spec"; import type { ShotSpec } from "./spec";
import { loadFonts } from "./theme"; import { loadFonts } from "./theme";
@@ -28,23 +30,74 @@ export function Shot(spec: ShotSpec) {
const k = pop(frame, fps, a.enterS ?? 0); const k = pop(frame, fps, a.enterS ?? 0);
if (a.kind === "crowd") { if (a.kind === "crowd") {
return ( return (
<div key={i} style={{ position: "absolute", left: "-2%", width: "104%", top: `${(a.y - 0.16) * 100}%`, height: "16%", <div key={i} style={{ position: "absolute", left: "-2%", width: "104%", top: `${(a.y - 0.34) * 100}%`, height: "34%",
opacity: k, transform: `translateY(${(1 - k) * 8}%)` }}> opacity: k, transform: `translateY(${(1 - k) * 8}%)` }}>
<CrowdFigure c={a} frame={frame} /> <CrowdFigure c={a} frame={frame} fps={fps} />
</div> </div>
); );
} }
if (a.character) { if (a.kind === "animal") {
// Personagem da biblioteca: mesmo visual em toda cena; muda expressão, pose e objeto na mão. // Animal (ou fila/casal): anda de x até walk.to; ave voando sobe e desce em onda. Olha para onde anda.
const ch = height * 0.36 * (a.scale ?? 1); const t = frame / fps;
const cw = (ch * 200) / 440; const w = a.walk;
const label = a.label ?? a.character.name; const s0 = w?.startS ?? 0;
const d = w?.dur ?? Math.max(0.5, spec.durationS - s0);
const p = w ? Math.max(0, Math.min(1, (t - s0) / d)) : 0;
const moving = !!w && t >= s0 && p < 1;
const flip = w ? w.to < a.x !== !!a.flip : !!a.flip;
const h = height * SPECIES_HEIGHT[a.species] * (a.scale ?? 1);
const n = a.count ?? 1;
const gap = a.gap ?? 0.16 * (a.scale ?? 1) * (SPECIES_HEIGHT[a.species] / 0.12);
const dir = w ? Math.sign(w.to - a.x) || 1 : flip ? -1 : 1;
const fly = !!a.fly && BIRDS.includes(a.species);
return ( return (
<div key={i} style={{ position: "absolute", left: a.x * width - cw / 2, top: a.y * height - ch, width: cw, height: ch, <React.Fragment key={i}>
opacity: Math.min(1, k * 1.5), transform: `translateY(${(1 - k) * 10}%) scaleX(${a.flip ? -1 : 1})` }}> {Array.from({ length: n }, (_, j) => (a.pair ? [0, 1] : [0]).map((m) => {
<CharacterFigure look={a.character.look} expression={a.expression} pose={a.pose} item={a.item} t={frame / fps} /> const x0 = a.x - dir * j * gap + (w ? (w.to - a.x) * p : 0);
{label && ( const y = a.y - m * 0.012 + (fly ? Math.sin(t * 2.4 + j) * 0.012 : 0);
<div style={{ position: "absolute", left: "50%", top: "-15%", transform: `translateX(-50%) scaleX(${a.flip ? -1 : 1})`, textAlign: "center" }}> const x = x0 - dir * m * gap * 0.35;
return (
<div key={`${j}-${m}`} style={{ position: "absolute", left: x * width - h / 2, top: y * height - h, width: h, height: h,
opacity: Math.min(1, k * 1.5), transform: `scale(${flip ? -1 : 1}, 1) translateY(${(1 - k) * 10}%)`, zIndex: m ? 0 : 1 }}>
<AnimalFigure species={a.species} color={a.color} t={t} walking={moving && !fly} flying={fly} carry={a.carry} seed={j * 3 + m} />
</div>
);
}))}
</React.Fragment>
);
}
if (a.character) {
// Personagem da biblioteca: mesmo visual em toda cena. Expressão, pose, andar, pular, falar… saem da
// linha do tempo (motion.ts), com a boca na fala (palavras + volume do áudio).
const t = frame / fps;
const st = evaluate({ x: a.x, expression: a.expression, pose: a.pose, face: a.face, body: a.body, flip: a.flip, timeline: a.timeline },
t, spec.durationS, spec.seed + i * 13, { words: spec.words ?? [], env: spec.audioEnv });
// Vista "insert": close das mãos (antebraços entrando por baixo) segurando o objeto.
if (a.framing === "insert") {
return (
<div key={i} style={{ position: "absolute", left: "-6%", width: "112%", top: `${(0.92 - 0.62) * 100}%`, aspectRatio: "1 / 1", opacity: Math.min(1, k * 1.5),
transform: `translateY(${(1 - k) * 8}%)` }}>
<HandsInsert look={a.character.look} item={a.item} t={t} />
</div>
);
}
// Caixa do desenho (200×440, cabeça ~1/3): corpo inteiro ~52% da altura do quadro; meio corpo corta nos
// joelhos; close corta na cintura, com a cabeça ocupando ~1/3 do quadro.
const box = a.framing === "close" ? 1.05 : a.framing === "medium" ? 0.8 : 0.52 * (a.scale ?? 1);
const zoom = box / 0.52;
const ch = height * box;
const cw = (ch * 200) / 440;
const baseY = a.framing === "close" ? 1.17 : a.framing === "medium" ? 1.04 : a.y;
const label = a.label ?? a.character.name;
const showLabel = label && Math.abs(st.rot) < 30;
return (
<div key={i} style={{ position: "absolute", left: (st.x + st.dx) * width - cw / 2, top: (baseY + st.dy) * height - ch, width: cw, height: ch,
opacity: Math.min(1, k * 1.5), transformOrigin: "50% 100%",
transform: `translateY(${(1 - k) * 10}%) rotate(${st.rot}deg) scale(${(st.flip ? -1 : 1) * st.sx}, ${st.sy})` }}>
{/* A luz da cena vem sempre do mesmo lado: espelhado, a sombra do desenho troca de lado. */}
<CharacterFigure look={a.character.look} item={a.item} t={t} state={st} shadeSide={st.flip ? -1 : 1} />
{showLabel && (
<div style={{ position: "absolute", left: zoom > 1 ? "8%" : "50%", top: zoom > 1 ? "22%" : "-15%", transform: `translateX(-50%) scaleX(${st.flip ? -1 : 1})`, textAlign: "center" }}>
<TagLabel text={label} /> <TagLabel text={label} />
{a.character.caption && <div style={{ marginTop: "0.6cqw" }}><TagLabel text={a.character.caption} tone="ok" size={2.4} /></div>} {a.character.caption && <div style={{ marginTop: "0.6cqw" }}><TagLabel text={a.character.caption} tone="ok" size={2.4} /></div>}
</div> </div>
@@ -77,9 +130,12 @@ export function Shot(spec: ShotSpec) {
</div> </div>
); );
})} })}
<LightLayer light={spec.light} palette={spec.palette} /> {spec.scene.kind === "place" && <PlaceForeground spec={spec} frame={frame} progress={progress} />}
<WeatherLayer spec={spec} frame={frame} />
<LightLayer light={spec.light} palette={spec.palette} spec={spec} />
{(spec.texts ?? []).map((t, i) => <TextLayer key={i} t={t} frame={frame} fps={fps} />)} {(spec.texts ?? []).map((t, i) => <TextLayer key={i} t={t} frame={frame} fps={fps} />)}
</AbsoluteFill> </AbsoluteFill>
{(spec.grain ?? 0.11) > 0 && <Grain opacity={spec.grain ?? 0.11} seed={spec.seed} />}
{spec.hud && <Hud hud={spec.hud} frame={frame} fps={fps} />} {spec.hud && <Hud hud={spec.hud} frame={frame} fps={fps} />}
{spec.words?.length ? <Captions words={spec.words} frame={frame} fps={fps} /> : null} {spec.words?.length ? <Captions words={spec.words} frame={frame} fps={fps} /> : null}
</AbsoluteFill> </AbsoluteFill>
+43 -13
View File
@@ -4,6 +4,9 @@ import React from "react";
import { COLORS } from "./colors"; import { COLORS } from "./colors";
import { rng } from "./random"; import { rng } from "./random";
import type { Crowd, Person } from "./spec"; import type { Crowd, Person } from "./spec";
import type { CharacterLook } from "./character";
import { CharacterFigure } from "./CharacterFigure";
import { evaluate } from "./motion";
/** Pessoa em pé num viewBox 200×420; (0,0) do grupo = pés no centro. */ /** Pessoa em pé num viewBox 200×420; (0,0) do grupo = pés no centro. */
export function PersonFigure({ p, frame, fps }: { p: Person; frame: number; fps: number }) { export function PersonFigure({ p, frame, fps }: { p: Person; frame: number; fps: number }) {
@@ -44,23 +47,50 @@ export function PersonFigure({ p, frame, fps }: { p: Person; frame: number; fps:
); );
} }
/** Fila de silhuetas pretas (multidão no portão). */ const SKINS = ["#f1c7a3", "#e0b48f", "#d09a70", "#c08055", "#a8704a", "#8d5a3b", "#6e4630"];
export function CrowdFigure({ c, frame }: { c: Crowd; frame: number }) { const HAIRS = ["#2a1e16", "#3a2a1e", "#6b4226", "#c9c9cf", "#e8c35a", "#1e1612", "#8a8a92"];
const CLOTHES = ["#3f6b8a", "#c8443a", "#5b6b3a", "#e8b13a", "#7a5ce0", "#2f6db3", "#d98a5c", "#4f7a4a", "#8a6f9e", "#56704a", "#e9ecef"];
const pick = <T,>(r: () => number, list: readonly T[]): T => list[Math.floor(r() * list.length) % list.length];
/** Aparência sorteada de quem está na multidão: cada um diferente (cabeça, altura, cabelo, roupa, acessório). */
export function crowdLook(seed: number): CharacterLook {
const r = rng(seed * 7919 + 17);
const female = r() < 0.45;
const old = r() < 0.25;
const hairStyle = female ? pick(r, ["long", "bun", "curly", "side"] as const) : pick(r, ["short", "side", "bald", "curly", "spiky", "cap"] as const);
const top = pick(r, female ? (["shirt", "dress", "hoodie", "jacket"] as const) : (["shirt", "jacket", "hoodie", "uniform", "shirt"] as const));
const acc: NonNullable<CharacterLook["accessories"]> = [];
const roll = r();
if (!female && roll < 0.14) { acc.push("helmet", "vest"); } else if (roll < 0.22) acc.push("scarf"); else if (roll < 0.3) acc.push("watch");
return {
build: pick(r, ["slim", "average", "average", "heavy"] as const), height: 0.86 + r() * 0.26, skin: pick(r, SKINS),
hair: { style: hairStyle, color: old ? "#c9c9cf" : pick(r, HAIRS) },
beard: { style: female ? "none" : pick(r, ["none", "none", "stubble", "mustache", "full", "goatee"] as const), color: old ? "#b0b0b8" : pick(r, HAIRS) },
glasses: r() < 0.22 ? pick(r, ["round", "square"] as const) : "none", brows: r() < 0.5 ? "thick" : "thin",
top: { style: top, color: pick(r, CLOTHES), accent: pick(r, CLOTHES) }, bottom: { style: female && r() < 0.3 ? "skirt" : "pants", color: pick(r, ["#2c3346", "#3a3f4a", "#5a4a3a", "#2b3a5a"]) },
shoes: pick(r, ["#1d1d24", "#5a3a22", "#f2f2f2"]), head: pick(r, ["round", "oval", "square", "wide"] as const), nose: pick(r, ["curve", "round", "button", "wide", "long"] as const),
lids: 0.1 + r() * 0.35, wrinkles: old ? 0.6 : 0, belly: !female && r() < 0.2, ...(acc.length ? { accessories: acc, accessoryColor: acc[0] === "helmet" ? "#f2a31a" : undefined } : {}),
};
}
/** Multidão: pessoas desenhadas com o mesmo traço dos personagens, cada uma diferente, em duas fileiras. */
export function CrowdFigure({ c, frame, fps = 30 }: { c: Crowd; frame: number; fps?: number }) {
const rand = rng(c.count * 31 + 3); const rand = rng(c.count * 31 + 3);
const people = Array.from({ length: c.count }, (_, i) => ({ x: (i + 0.5) / c.count, h: 0.8 + rand() * 0.35, p: rand() * 6 })); const people = Array.from({ length: c.count }, (_, i) => ({ i, x: (i + 0.5) / c.count + (rand() - 0.5) * 0.04, back: i % 2 === 1, p: rand() * 6 }))
.sort((a, b) => Number(b.back) - Number(a.back));
const t = frame / fps;
return ( return (
<svg viewBox="0 0 1000 300" width="100%" height="100%" preserveAspectRatio="none" overflow="visible"> <div style={{ position: "absolute", inset: 0 }}>
{people.map((m, i) => { {people.map((m) => {
const bob = Math.sin(frame / 14 + m.p) * 3; const h = m.back ? 78 : 92;
const x = m.x * 1000; const st = evaluate({ x: 0, expression: pick(rng(m.i + 5), ["neutral", "smile", "happy", "neutral", "smirk", "surprised"] as const) }, t, 3600, m.i * 7 + 3);
const h = 260 * m.h;
return ( return (
<g key={i} transform={`translate(${x} ${300 + bob})`} fill="#06070f"> <div key={m.i} style={{ position: "absolute", left: `${m.x * 100 - h * 0.11}%`, bottom: `${(m.back ? 8 : 0) + Math.sin(t * 2 + m.p) * 0.4}%`, height: `${h}%`, aspectRatio: "200 / 440",
<rect x={-26} y={-h * 0.62} width={52} height={h * 0.62} rx={18} /> filter: m.back ? "brightness(0.82)" : undefined }}>
<circle cx={0} cy={-h * 0.75} r={h * 0.13} /> <CharacterFigure look={crowdLook(m.i + c.count * 13)} t={t} state={st} shadeSide={1} />
</g> </div>
); );
})} })}
</svg> </div>
); );
} }
+157
View File
@@ -0,0 +1,157 @@
// Animais do estilo Cartoon: figuras reaproveitáveis em qualquer história (não são cena pronta). Cada espécie
// é desenhada por formas chapadas no mesmo traço dos personagens, olhando para a direita, com as patas em
// (100, 200) num viewBox 200×200. Andar mexe as patas; ave voando bate as asas. Cor e escala vêm do spec.
import React from "react";
export const SPECIES = ["dove", "raven", "elephant", "giraffe", "lion", "sheep", "horse", "camel"] as const;
export type Species = (typeof SPECIES)[number];
/** Altura de referência de cada espécie (fração da altura do quadro, com scale 1). */
export const SPECIES_HEIGHT: Record<Species, number> = {
dove: 0.05, raven: 0.055, elephant: 0.2, giraffe: 0.3, lion: 0.12, sheep: 0.085, horse: 0.17, camel: 0.19,
};
/** Aves podem voar (asas batendo, sem patas no chão). */
export const BIRDS: readonly Species[] = ["dove", "raven"];
const INK = "#15161f";
const DEFAULT_COLOR: Record<Species, string> = {
dove: "#f4f4f8", raven: "#23242e", elephant: "#9aa0ab", giraffe: "#e8b54a", lion: "#d99a3a", sheep: "#f1ece0", horse: "#8a5a3a", camel: "#c9a06a",
};
function shade(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16);
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v * k))).toString(16).padStart(2, "0");
return `#${c((n >> 16) & 255)}${c((n >> 8) & 255)}${c(n & 255)}`;
}
/** Perna que balança pelo quadril: `phase` vem do passo (0 parado). */
function Leg({ x, y, len, w, fill, swing }: { x: number; y: number; len: number; w: number; fill: string; swing: number }) {
return <rect x={x - w / 2} y={y} width={w} height={len} rx={w / 2.4} fill={fill} transform={`rotate(${swing} ${x} ${y})`} />;
}
function Eye({ x, y, r = 4.5, light }: { x: number; y: number; r?: number; light?: boolean }) {
return <g><circle cx={x} cy={y} r={r} fill={light ? "#ffffff" : INK} />{light ? <circle cx={x + 1} cy={y} r={r * 0.55} fill={INK} /> : <circle cx={x + 1.3} cy={y - 1.3} r={r * 0.3} fill="#ffffff" />}</g>;
}
/** Ramo de oliveira no bico (pomba da história do dilúvio, mas serve para qualquer ave). */
function Branch({ x, y }: { x: number; y: number }) {
return (
<g transform={`translate(${x} ${y})`}>
<path d="M0 0 Q14 6 30 4" stroke="#6b4a2a" strokeWidth={2.4} fill="none" strokeLinecap="round" />
{[[8, 2, -30], [16, 6, 30], [22, 2, -30], [28, 6, 25]].map(([lx, ly, r], i) => <ellipse key={i} cx={lx} cy={ly} rx={6} ry={2.6} fill={i % 2 ? "#7fa24a" : "#5f8a3a"} transform={`rotate(${r} ${lx} ${ly})`} />)}
</g>
);
}
export function AnimalFigure({ species, color, t = 0, walking = false, flying = false, carry, seed = 0 }: {
species: Species; color?: string; t?: number; walking?: boolean; flying?: boolean; carry?: "olive"; seed?: number;
}) {
const c = color ?? DEFAULT_COLOR[species];
const dark = shade(c, 0.78);
// Passo: pernas da frente e de trás em oposição; corpo sobe e desce de leve.
const ph = walking ? Math.sin((t + seed * 0.37) * Math.PI * 2 * 1.6) : 0;
const bob = walking ? Math.abs(ph) * -3 : Math.sin(t * 2 + seed) * 0.8;
const flap = flying ? Math.sin((t + seed * 0.21) * Math.PI * 2 * 3.2) : 0;
const body = (inner: React.ReactNode) => <svg viewBox="0 0 200 200" width="100%" height="100%" overflow="visible"><g transform={`translate(0 ${bob})`}>{inner}</g></svg>;
switch (species) {
case "dove": case "raven": {
const beak = species === "dove" ? "#e8a04a" : "#3a3b46";
if (flying) {
return body(<g>
<path d={`M78 112 Q60 ${100 - flap * 50} 30 ${96 - flap * 70} Q66 ${112 - flap * 20} 84 124 Z`} fill={dark} />
<ellipse cx={100} cy={122} rx={36} ry={18} fill={c} />
<path d="M66 120 L40 112 L44 132 Z" fill={dark} />
<circle cx={134} cy={112} r={15} fill={c} />
<path d="M147 110 L162 114 L147 118 Z" fill={beak} />
<Eye x={138} y={109} r={3.2} />
<path d={`M104 116 Q118 ${100 - flap * 48} 150 ${92 - flap * 64} Q124 ${114 - flap * 18} 112 126 Z`} fill={c} stroke={dark} strokeWidth={2} />
{carry === "olive" && <Branch x={156} y={116} />}
</g>);
}
return body(<g>
<path d="M86 186 L84 200 M106 186 L108 200" stroke="#e07a4a" strokeWidth={4} strokeLinecap="round" />
<ellipse cx={96} cy={164} rx={36} ry={26} fill={c} />
<path d="M64 160 L36 150 L42 176 Z" fill={dark} />
<path d="M80 158 Q100 146 118 166 Q100 178 80 158 Z" fill={dark} />
<circle cx={128} cy={134} r={17} fill={c} />
<path d="M143 132 L160 137 L143 142 Z" fill={beak} />
<Eye x={132} y={130} r={3.4} />
{carry === "olive" && <Branch x={154} y={138} />}
</g>);
}
case "elephant": return body(<g>
<Leg x={52} y={128} len={70} w={26} fill={dark} swing={-ph * 10} />
<Leg x={128} y={128} len={70} w={26} fill={dark} swing={ph * 10} />
<ellipse cx={92} cy={112} rx={66} ry={50} fill={c} />
<Leg x={72} y={130} len={68} w={26} fill={c} swing={ph * 10} />
<Leg x={148} y={128} len={70} w={26} fill={c} swing={-ph * 10} />
<path d="M28 104 Q16 116 22 134" stroke={dark} strokeWidth={5} fill="none" strokeLinecap="round" />
<circle cx={154} cy={90} r={34} fill={c} />
<path d={`M176 98 Q192 128 182 158 Q178 ${170 + ph * 4} 190 ${172 + ph * 4}`} stroke={c} strokeWidth={16} fill="none" strokeLinecap="round" />
<path d="M130 70 Q100 74 104 108 Q116 132 140 116 Z" fill={dark} />
<path d="M172 112 L184 124" stroke="#f4f0e4" strokeWidth={6} strokeLinecap="round" />
<Eye x={166} y={84} r={4} />
</g>);
case "giraffe": return body(<g>
<Leg x={58} y={118} len={80} w={11} fill={dark} swing={-ph * 12} />
<Leg x={118} y={118} len={80} w={11} fill={dark} swing={ph * 12} />
<ellipse cx={90} cy={112} rx={44} ry={24} fill={c} />
<Leg x={70} y={120} len={78} w={11} fill={c} swing={ph * 12} />
<Leg x={128} y={118} len={80} w={11} fill={c} swing={-ph * 12} />
<path d="M116 100 L150 10 L166 16 L134 108 Z" fill={c} />
{[[80, 104], [100, 116], [66, 116], [104, 98], [138, 60], [148, 34], [130, 84]].map(([x, y], i) => <circle key={i} cx={x} cy={y} r={6} fill={shade(c, 0.62)} />)}
<ellipse cx={168} cy={14} rx={22} ry={12} fill={c} />
<path d="M156 0 L154 -14 M164 0 L164 -14" stroke={dark} strokeWidth={4} strokeLinecap="round" />
<Eye x={170} y={9} r={3.4} />
<path d="M46 104 Q36 120 40 136" stroke={dark} strokeWidth={3} fill="none" />
</g>);
case "lion": {
const mane = shade(c, 0.62);
return body(<g>
<Leg x={58} y={138} len={60} w={15} fill={dark} swing={-ph * 12} />
<Leg x={124} y={138} len={60} w={15} fill={dark} swing={ph * 12} />
<ellipse cx={92} cy={138} rx={52} ry={26} fill={c} />
<Leg x={72} y={140} len={58} w={15} fill={c} swing={ph * 12} />
<Leg x={136} y={138} len={60} w={15} fill={c} swing={-ph * 12} />
<path d={`M42 132 Q20 ${120 + ph * 6} 22 102`} stroke={c} strokeWidth={6} fill="none" strokeLinecap="round" />
<circle cx={22} cy={100} r={7} fill={mane} />
<circle cx={146} cy={112} r={34} fill={mane} />
<circle cx={150} cy={116} r={22} fill={c} />
<ellipse cx={164} cy={124} rx={9} ry={7} fill={shade(c, 1.15)} />
<circle cx={168} cy={121} r={3.4} fill={INK} />
<Eye x={156} y={108} r={3.4} />
</g>);
}
case "sheep": return body(<g>
<Leg x={70} y={150} len={50} w={9} fill="#3a3540" swing={-ph * 12} />
<Leg x={118} y={150} len={50} w={9} fill="#3a3540" swing={ph * 12} />
{[[66, 140], [86, 128], [108, 128], [126, 140], [96, 152], [76, 156], [116, 156]].map(([x, y], i) => <circle key={i} cx={x} cy={y} r={22} fill={c} />)}
<Leg x={82} y={160} len={40} w={9} fill="#2e2a33" swing={ph * 12} />
<Leg x={128} y={156} len={44} w={9} fill="#2e2a33" swing={-ph * 12} />
<ellipse cx={152} cy={128} rx={16} ry={20} fill="#3a3540" />
<ellipse cx={140} cy={116} rx={10} ry={5} fill="#3a3540" transform="rotate(-20 140 116)" />
<circle cx={146} cy={110} r={12} fill={c} />
<Eye x={158} y={124} r={3.2} light />
</g>);
case "horse": case "camel": {
const camel = species === "camel";
return body(<g>
<Leg x={60} y={116} len={84} w={13} fill={dark} swing={-ph * 14} />
<Leg x={124} y={116} len={84} w={13} fill={dark} swing={ph * 14} />
<ellipse cx={92} cy={110} rx={52} ry={28} fill={c} />
{camel && <path d="M62 92 Q76 50 96 88 Q110 54 126 92 Z" fill={c} />}
<Leg x={74} y={118} len={82} w={13} fill={c} swing={ph * 14} />
<Leg x={134} y={116} len={84} w={13} fill={c} swing={-ph * 14} />
<path d={camel ? "M132 100 Q160 96 158 60 L174 56 Q178 104 142 116 Z" : "M128 96 L152 50 L170 58 L146 112 Z"} fill={c} />
<ellipse cx={camel ? 178 : 168} cy={camel ? 56 : 56} rx={camel ? 17 : 22} ry={camel ? 11 : 13} fill={c} transform={`rotate(${camel ? 10 : 30} ${camel ? 178 : 168} 56)`} />
{!camel && <path d="M150 48 Q132 70 128 98" stroke={shade(c, 0.5)} strokeWidth={9} fill="none" strokeLinecap="round" />}
{!camel && <path d={`M42 104 Q24 ${120 + ph * 4} 30 146`} stroke={shade(c, 0.5)} strokeWidth={9} fill="none" strokeLinecap="round" />}
{camel && <path d="M42 106 Q34 120 38 134" stroke={dark} strokeWidth={4} fill="none" />}
<path d="M158 42 L156 30 L166 40 Z" fill={dark} />
<Eye x={camel ? 182 : 170} y={camel ? 52 : 50} r={3.4} />
</g>);
}
default: return null;
}
}
+39 -8
View File
@@ -4,16 +4,26 @@
export const BUILDS = ["slim", "average", "heavy"] as const; export const BUILDS = ["slim", "average", "heavy"] as const;
export const HAIR_STYLES = ["short", "side", "bun", "long", "curly", "spiky", "bald", "cap"] as const; export const HAIR_STYLES = ["short", "side", "bun", "long", "curly", "spiky", "bald", "cap"] as const;
export const BEARD_STYLES = ["none", "stubble", "mustache", "full", "goatee"] as const; export const BEARD_STYLES = ["none", "stubble", "mustache", "full", "goatee", "long"] as const;
export const GLASSES = ["none", "round", "square", "sun"] as const; export const GLASSES = ["none", "round", "square", "sun"] as const;
export const BROWS = ["thin", "thick"] as const; export const BROWS = ["thin", "thick"] as const;
export const TOP_STYLES = ["shirt", "jacket", "hoodie", "dress", "uniform"] as const; /** "robe" = túnica longa até a canela (com faixa na cintura), de roupa antiga. */
export const TOP_STYLES = ["shirt", "jacket", "hoodie", "dress", "uniform", "robe"] as const;
export const BOTTOM_STYLES = ["pants", "shorts", "skirt"] as const; export const BOTTOM_STYLES = ["pants", "shorts", "skirt"] as const;
export const EXPRESSIONS = ["neutral", "happy", "sad", "worried", "angry", "surprised", "scared"] as const; export const HEAD_SHAPES = ["round", "oval", "square", "wide"] as const;
export const POSES = ["stand", "point", "wave", "hold", "arms_up", "shrug", "think"] as const; export const NOSES = ["button", "curve", "round", "long", "wide"] as const;
/** Calçado: sapato fechado (cor em `shoes`), sandália de tiras ou pé descalço. */
export const FOOTWEAR = ["shoes", "sandals", "bare"] as const;
/** Acessórios desenhados por cima da roupa (combináveis). */
export const ACCESSORIES = ["towel", "whistle", "tie", "vest", "helmet", "watch", "badge", "apron", "scarf", "headset", "chain"] as const;
export type Accessory = (typeof ACCESSORIES)[number];
// Expressões e poses são ATALHOS do rig (rig.ts): parâmetros contínuos que dá para ajustar e misturar.
import { EXPRESSION_NAMES, POSE_NAMES, type ExpressionName, type PoseName } from "./rig";
export type Expression = (typeof EXPRESSIONS)[number]; export const EXPRESSIONS = EXPRESSION_NAMES;
export type Pose = (typeof POSES)[number]; export const POSES = POSE_NAMES;
export type Expression = ExpressionName;
export type Pose = PoseName;
export type CharacterLook = { export type CharacterLook = {
build: (typeof BUILDS)[number]; build: (typeof BUILDS)[number];
@@ -27,6 +37,20 @@ export type CharacterLook = {
top: { style: (typeof TOP_STYLES)[number]; color: string; accent?: string }; top: { style: (typeof TOP_STYLES)[number]; color: string; accent?: string };
bottom: { style: (typeof BOTTOM_STYLES)[number]; color: string }; bottom: { style: (typeof BOTTOM_STYLES)[number]; color: string };
shoes: string; shoes: string;
/** Tipo de calçado (padrão "shoes"); a cor continua em `shoes`. */
footwear?: (typeof FOOTWEAR)[number];
/** Detalhe de ilustração (opcionais; sem eles o personagem sai no traço simples). */
head?: (typeof HEAD_SHAPES)[number];
nose?: (typeof NOSES)[number];
/** Pálpebra de cima de base (0 olho aberto … 0,6 meio caído, olhar cansado/esperto). */
lids?: number;
/** Rugas (0 nenhuma … 1 muitas: testa e canto dos olhos). */
wrinkles?: number;
/** Barriga saliente (o "forte" de barriga). */
belly?: boolean;
accessories?: Accessory[];
/** Cor dos acessórios principais (toalha, gravata, colete, capacete…). */
accessoryColor?: string;
}; };
/** Ficha do personagem na biblioteca. `kind: "3d"` aponta para a pessoa articulada da Godot (godot/kits). */ /** Ficha do personagem na biblioteca. `kind: "3d"` aponta para a pessoa articulada da Godot (godot/kits). */
@@ -73,8 +97,15 @@ export function validateLook(look: unknown): string[] {
if (!one(BROWS, l.brows)) errors.push(`brows: ${BROWS.join("|")}`); if (!one(BROWS, l.brows)) errors.push(`brows: ${BROWS.join("|")}`);
if (!one(TOP_STYLES, l.top?.style)) errors.push(`top.style: ${TOP_STYLES.join("|")}`); if (!one(TOP_STYLES, l.top?.style)) errors.push(`top.style: ${TOP_STYLES.join("|")}`);
if (!one(BOTTOM_STYLES, l.bottom?.style)) errors.push(`bottom.style: ${BOTTOM_STYLES.join("|")}`); if (!one(BOTTOM_STYLES, l.bottom?.style)) errors.push(`bottom.style: ${BOTTOM_STYLES.join("|")}`);
if (l.head !== undefined && !one(HEAD_SHAPES, l.head)) errors.push(`head: ${HEAD_SHAPES.join("|")}`);
if (l.nose !== undefined && !one(NOSES, l.nose)) errors.push(`nose: ${NOSES.join("|")}`);
if (l.lids !== undefined && !(typeof l.lids === "number" && l.lids >= 0 && l.lids <= 0.8)) errors.push("lids entre 0 e 0,8");
if (l.wrinkles !== undefined && !(typeof l.wrinkles === "number" && l.wrinkles >= 0 && l.wrinkles <= 1)) errors.push("wrinkles entre 0 e 1");
if (l.accessories !== undefined && (!Array.isArray(l.accessories) || l.accessories.some((a) => !one(ACCESSORIES, a)))) errors.push(`accessories: ${ACCESSORIES.join("|")}`);
if (l.footwear !== undefined && !one(FOOTWEAR, l.footwear)) errors.push(`footwear: ${FOOTWEAR.join("|")}`);
if (l.accessoryColor !== undefined && !HEX.test(l.accessoryColor)) errors.push("accessoryColor: cor #rrggbb");
return errors; return errors;
} }
export const isExpression = (v: unknown): v is Expression => one(EXPRESSIONS, v); export const isExpression = (v: unknown): v is Expression => typeof v === "string" && (EXPRESSIONS as string[]).includes(v);
export const isPose = (v: unknown): v is Pose => one(POSES, v); export const isPose = (v: unknown): v is Pose => typeof v === "string" && (POSES as string[]).includes(v);
+379
View File
@@ -0,0 +1,379 @@
// Construções e objetos de exterior: casa, prédio, muro, fachada com colunas, loja com toldo, cerca, poste…
// Base em (0,0); luz da esquerda (a face da direita fica na sombra). Medidas pensadas para uma pessoa de ~600.
import React from "react";
import { mix, type Paint } from "./paint";
import type { Draw } from "./nature";
/** Caixa em 2 tons: frente na cor base, faixa da direita na sombra e (opcional) topo iluminado. */
export function Box({ x, y, w, h, fill, p, side = 0.14, top = 0, rx = 0, k = 0.32 }: {
x: number; y: number; w: number; h: number; fill: string; p: Paint; side?: number; top?: number; rx?: number; k?: number;
}) {
return <g>
<rect x={x} y={y} width={w} height={h} rx={rx} fill={p.c(fill)} />
{side > 0 && <rect x={x + w * (1 - side)} y={y} width={w * side} height={h} rx={Math.min(rx, (w * side) / 2)} fill={p.lo(fill, k)} />}
{top > 0 && <rect x={x} y={y} width={w} height={top} rx={Math.min(rx, top / 2)} fill={p.hi(fill, 0.28)} />}
</g>;
}
/** Janela de fachada: moldura, vidro (aceso à noite, céu refletido de dia), cruz e peitoril. */
export function FacadeWindow({ x, y, w, h, p, lit, frame = "#efe6d6", arch = false }: { x: number; y: number; w: number; h: number; p: Paint; lit: boolean; frame?: string; arch?: boolean }) {
const glass = lit ? mix(p.pal.light, "#ffb050", 0.15) : mix(p.pal.sky[1], p.pal.ink, p.night ? 0.55 : 0.18);
const top = arch ? `M${x} ${y + w / 2} A${w / 2} ${w / 2} 0 0 1 ${x + w} ${y + w / 2} L${x + w} ${y + h} L${x} ${y + h} Z` : "";
const inset = 10;
return <g>
{arch ? <path d={top} fill={p.c(frame)} /> : <rect x={x} y={y} width={w} height={h} rx={4} fill={p.c(frame)} />}
{arch
? <path d={`M${x + inset} ${y + w / 2} A${w / 2 - inset} ${w / 2 - inset} 0 0 1 ${x + w - inset} ${y + w / 2} L${x + w - inset} ${y + h - inset} L${x + inset} ${y + h - inset} Z`} fill={p.c(glass)} />
: <rect x={x + inset} y={y + inset} width={w - inset * 2} height={h - inset * 2} fill={p.c(glass)} />}
<path d={`M${x + inset} ${y + h - inset} L${x + w - inset} ${y + h - inset} L${x + w - inset} ${y + h * 0.45} Z`} fill={lit ? p.hi(glass, 0.3) : p.lo(glass, 0.25)} opacity={0.6} />
{!lit && <path d={`M${x + w * 0.25} ${y + h * 0.75} L${x + w * 0.55} ${y + h * 0.2} L${x + w * 0.68} ${y + h * 0.2} L${x + w * 0.38} ${y + h * 0.75} Z`} fill="#ffffff" opacity={0.18} />}
<rect x={x + w / 2 - 4} y={y + inset} width={8} height={h - inset * 2} fill={p.c(frame)} />
<rect x={x + inset} y={y + h * 0.48} width={w - inset * 2} height={8} fill={p.c(frame)} />
<rect x={x - 8} y={y + h - 4} width={w + 16} height={14} rx={3} fill={p.hi(frame, 0.2)} />
<rect x={x - 8} y={y + h + 10} width={w + 16} height={8} fill={p.lo(frame, 0.5)} opacity={0.6} />
</g>;
}
/** Linhas de telha num trapézio (um path só: fileiras + juntas desencontradas). */
function tiles(x0: number, x1: number, y0: number, y1: number, rows: number, inset: number): string {
let d = "";
for (let k = 1; k <= rows; k++) {
const t = k / rows;
const y = y0 + (y1 - y0) * t;
const l = x0 + inset * (1 - t);
const r = x1 - inset * (1 - t);
d += `M${l} ${y} L${r} ${y} `;
const yPrev = y0 + (y1 - y0) * ((k - 1) / rows);
for (let x = l + (k % 2 ? 22 : 0); x < r; x += 44) d += `M${x} ${y} L${x} ${yPrev + 6} `;
}
return d;
}
export const BUILT: Record<string, Draw> = {
house: (p, color) => {
const wall = color ?? mix(p.pal.near, "#f2e2c6", 0.45);
const roof = mix("#c4613a", p.pal.near, 0.15);
const lit = () => p.night && p.r() > 0.35;
const doorX = p.r() > 0.5 ? 60 : -170;
return <g>
{/* lado da casa (fundo, na sombra) */}
<polygon points="300,0 300,-460 392,-430 392,-14" fill={p.lo(wall, 0.42)} />
<polygon points="300,-460 392,-430 392,-400 300,-424" fill={p.lo(wall, 0.6)} />
<rect x={-300} y={-460} width={600} height={460} fill={p.c(wall)} />
<rect x={-300} y={-460} width={26} height={460} fill={p.hi(wall, 0.14)} />
{[[-240, -120, 70, 26], [140, -320, 90, 22], [-80, -380, 60, 18]].map(([x, y, w, h], i) => <rect key={i} x={x} y={y} width={w} height={h} rx={h / 2} fill={p.lo(wall, 0.14)} />)}
<rect x={-300} y={-36} width={600} height={36} fill={p.lo(wall, 0.38)} />
{/* telhado de telha: frente, quina iluminada à esquerda e água da direita na sombra */}
<polygon points="-350,-452 -235,-660 235,-660 350,-452" fill={p.c(roof)} />
<path d={tiles(-350, 350, -660, -452, 5, 115)} stroke={p.lo(roof, 0.4)} strokeWidth={5} fill="none" />
<polygon points="-350,-452 -235,-660 -205,-660 -300,-452" fill={p.hi(roof, 0.22)} />
<polygon points="235,-660 350,-452 430,-430 300,-640" fill={p.lo(roof, 0.4)} />
<rect x={-356} y={-458} width={712} height={16} rx={4} fill={p.lo(roof, 0.2)} />
<rect x={-300} y={-442} width={600} height={30} fill={p.lo(wall, 0.5)} opacity={0.8} />
<rect x={150} y={-720} width={54} height={90} fill={p.c(mix(roof, "#8a5a4a", 0.4))} /><rect x={184} y={-720} width={20} height={90} fill={p.lo(roof, 0.5)} />
{/* janelas e porta */}
{(doorX > 0 ? [-230, -60] : [-20, 160]).map((x) => <FacadeWindow key={x} x={x} y={-330} w={110} h={130} p={p} lit={lit()} />)}
<rect x={doorX - 12} y={-282} width={124} height={282} rx={4} fill={p.c("#efe6d6")} />
<rect x={doorX} y={-270} width={100} height={270} fill={p.c(mix("#7a4a2c", wall, 0.1))} />
<rect x={doorX + 74} y={-270} width={26} height={270} fill={p.lo("#7a4a2c", 0.4)} />
<rect x={doorX + 14} y={-250} width={60} height={90} rx={3} fill={p.lo("#7a4a2c", 0.25)} />
<circle cx={doorX + 80} cy={-130} r={7} fill={p.c("#e6c27a")} />
<rect x={doorX - 24} y={-12} width={148} height={12} fill={p.hi("#b0a898", 0.1)} />
</g>;
},
building: (p, color) => {
const floors = 4 + Math.floor(p.r() * 4);
const fh = 150;
const H = floors * fh;
const body = color ?? p.pal.far;
const rows = Array.from({ length: floors - 1 }, (_, f) => f);
return <g>
<polygon points={`210,0 210,${-H} 276,${-H + 26} 276,0`} fill={p.lo(body, 0.42)} />
<rect x={-210} y={-H} width={420} height={H} fill={p.c(body)} />
<rect x={-210} y={-H} width={22} height={H} fill={p.hi(body, 0.14)} />
<rect x={-224} y={-H - 26} width={448} height={30} fill={p.hi(body, 0.2)} />
<polygon points={`224,${-H - 26} 290,${-H} 290,${-H + 4} 224,${-H + 4}`} fill={p.lo(body, 0.5)} />
{rows.map((f) => <rect key={f} x={-210} y={-(f + 1) * fh - 6} width={420} height={8} fill={p.lo(body, 0.2)} />)}
{rows.flatMap((f) => [-160, -40, 80].map((x) => (
<FacadeWindow key={`${f}${x}`} x={x} y={-(f + 2) * fh + 28} w={80} h={90} p={p} lit={p.night ? p.r() > 0.55 : false} frame={mix(body, "#ffffff", 0.45)} />
)))}
<rect x={-70} y={-130} width={140} height={130} fill={p.c(mix(body, p.pal.ink, 0.6))} />
<rect x={-60} y={-120} width={120} height={120} fill={p.c(p.night ? mix(p.pal.light, "#ffb050", 0.3) : mix(p.pal.sky[1], p.pal.ink, 0.4))} opacity={0.85} />
<rect x={-96} y={-150} width={192} height={22} fill={p.c(mix(body, p.pal.ink, 0.35))} />
<rect x={-210} y={-20} width={420} height={20} fill={p.lo(body, 0.45)} />
</g>;
},
wall: (p, color) => {
// Muro comprido de reboco com capa por cima e pilares (passa da borda do quadro).
const w = color ?? mix(p.pal.near, "#c8885e", 0.5);
const patches = Array.from({ length: 7 }, () => [-660 + p.r() * 1260, -250 + p.r() * 190, 40 + p.r() * 90]);
return <g>
<rect x={-720} y={-300} width={1440} height={300} fill={p.c(w)} />
{patches.map(([x, y, s], i) => <rect key={i} x={x} y={y} width={s} height={s * 0.36} rx={s * 0.18} fill={i % 2 ? p.lo(w, 0.14) : p.hi(w, 0.14)} />)}
{[-540, -180, 180, 540].map((x) => <g key={x}><rect x={x - 26} y={-312} width={52} height={312} fill={p.c(w)} /><rect x={x + 8} y={-312} width={18} height={312} fill={p.lo(w, 0.3)} /></g>)}
<rect x={-730} y={-324} width={1460} height={28} rx={4} fill={p.hi(w, 0.22)} />
<rect x={-730} y={-300} width={1460} height={22} fill={p.lo(w, 0.5)} opacity={0.75} />
<rect x={-720} y={-34} width={1440} height={34} fill={p.lo(w, 0.4)} />
</g>;
},
facade: (p, color) => {
// Prédio público visto de frente: escadaria, colunas, frontão triangular.
const stone = color ?? "#e6dac2";
const back = p.lo(stone, 0.42);
const cols = [-400, -240, -80, 80, 240, 400];
return <g>
<rect x={-470} y={-690} width={940} height={600} fill={back} />
{[-320, -160, 0, 160, 320].map((x) => <path key={x} d={`M${x - 42} -180 L${x - 42} -470 A42 42 0 0 1 ${x + 42} -470 L${x + 42} -180 Z`} fill={p.c(mix(p.pal.sky[1], p.pal.ink, p.night ? 0.7 : 0.45))} />)}
{[-320, -160, 0, 160, 320].map((x) => <rect key={x} x={x - 42} y={-200} width={84} height={20} fill={p.lo(stone, 0.45)} />)}
{cols.map((x) => <g key={x}>
<rect x={x - 32} y={-660} width={64} height={560} fill={p.c(stone)} />
<rect x={x - 32} y={-660} width={14} height={560} fill={p.hi(stone, 0.3)} />
<rect x={x + 8} y={-660} width={24} height={560} fill={p.lo(stone, 0.42)} />
<rect x={x - 46} y={-686} width={92} height={28} rx={4} fill={p.hi(stone, 0.12)} />
<rect x={x + 18} y={-686} width={28} height={28} fill={p.lo(stone, 0.3)} />
<rect x={x - 44} y={-120} width={88} height={24} fill={p.c(stone)} /><rect x={x + 16} y={-120} width={28} height={24} fill={p.lo(stone, 0.3)} />
</g>)}
<rect x={-500} y={-770} width={1000} height={86} fill={p.c(stone)} />
<rect x={-500} y={-704} width={1000} height={20} fill={p.lo(stone, 0.35)} />
<rect x={-500} y={-770} width={1000} height={14} fill={p.hi(stone, 0.3)} />
<polygon points="-530,-770 0,-930 530,-770" fill={p.c(stone)} />
<polygon points="-440,-786 0,-904 440,-786" fill={p.lo(stone, 0.22)} />
<polygon points="0,-930 530,-770 500,-770 0,-916" fill={p.lo(stone, 0.4)} />
<polygon points="-530,-770 0,-930 0,-916 -500,-770" fill={p.hi(stone, 0.3)} />
{/* base e degraus */}
<rect x={-490} y={-100} width={980} height={30} fill={p.c(stone)} />
{[0, 1, 2].map((i) => <g key={i}>
<rect x={-520 - i * 30} y={-70 + i * 24} width={1040 + i * 60} height={24} fill={p.c(mix(stone, "#a8a090", 0.2))} />
<rect x={-520 - i * 30} y={-70 + i * 24} width={1040 + i * 60} height={6} fill={p.hi(stone, 0.35)} />
</g>)}
</g>;
},
shopfront: (p, color) => {
// Loja/oficina de rua: toldo listrado, letreiro em branco, porta de enrolar meio aberta e o interior escuro.
const wall = mix(p.pal.near, "#eeb04a", 0.75);
const awn = color ?? "#d65a3a";
const inside = mix(wall, p.pal.ink, 0.62);
const n = 9;
const stripe = 800 / n;
return <g>
<polygon points="400,0 400,-700 470,-670 470,-10" fill={p.lo(wall, 0.42)} />
<rect x={-400} y={-700} width={800} height={700} fill={p.c(wall)} />
<rect x={-400} y={-700} width={24} height={700} fill={p.hi(wall, 0.16)} />
{/* vão da garagem com ferramentas na parede do fundo */}
<rect x={-300} y={-420} width={600} height={420} fill={p.c(inside)} />
<rect x={-300} y={-420} width={600} height={60} fill={p.lo(inside, 0.4)} />
<rect x={40} y={-330} width={220} height={150} rx={6} fill={p.c(mix(inside, "#8a6a4a", 0.35))} />
{[70, 110, 150, 190, 230].map((x, i) => <rect key={x} x={x - 6} y={-310} width={12} height={i % 2 ? 90 : 70} rx={5} fill={p.c(i % 3 ? "#b8bcc4" : "#e8b030")} />)}
<rect x={-270} y={-200} width={200} height={14} fill={p.c(mix(inside, "#8a6a4a", 0.4))} />
{[0, 1].map((i) => <ellipse key={i} cx={-200 + i * 50} cy={-60 - i * 10} rx={60} ry={60} fill={p.c("#2a2a32")} />)}
{[0, 1].map((i) => <ellipse key={i} cx={-200 + i * 50} cy={-60 - i * 10} rx={26} ry={26} fill={p.c("#4a4a56")} />)}
<rect x={-300} y={-440} width={600} height={70} fill={p.c(mix(wall, "#c8c8cc", 0.6))} />
{[0, 1, 2, 3].map((i) => <rect key={i} x={-300} y={-432 + i * 16} width={600} height={4} fill={p.lo("#c8c8cc", 0.35)} />)}
<rect x={-312} y={-452} width={24} height={452} fill={p.hi(wall, 0.1)} /><rect x={288} y={-452} width={24} height={452} fill={p.lo(wall, 0.25)} />
{/* letreiro */}
<rect x={-340} y={-580} width={680} height={110} rx={10} fill={p.c("#f4ecdc")} />
<rect x={-340} y={-490} width={680} height={20} rx={6} fill={p.lo("#f4ecdc", 0.28)} />
{/* toldo listrado com a borda em ondas */}
<polygon points="-380,-700 380,-700 450,-610 -450,-610" fill={p.c(awn)} />
{Array.from({ length: n }, (_, i) => i % 2 === 1 && (
<polygon key={i} points={`${-380 + i * (760 / n)},-700 ${-380 + (i + 1) * (760 / n)},-700 ${-450 + (i + 1) * stripe * 1.125},-610 ${-450 + i * stripe * 1.125},-610`} fill={p.lo(awn, 0.2)} />
))}
{Array.from({ length: n }, (_, i) => <path key={i} d={`M${-450 + i * 100} -610 a50 26 0 0 0 100 0 Z`} fill={i % 2 ? p.lo(awn, 0.2) : p.c(awn)} />)}
<rect x={-450} y={-614} width={900} height={10} fill={p.lo(awn, 0.25)} />
<rect x={-400} y={-584} width={800} height={16} fill={p.lo(wall, 0.45)} opacity={0.7} />
<rect x={-400} y={-28} width={800} height={28} fill={p.lo(wall, 0.4)} />
</g>;
},
fence: (p, color) => {
const wood = color ?? mix(p.pal.trunk, "#d8c0a0", 0.35);
const xs = Array.from({ length: 13 }, (_, i) => -450 + i * 75);
const body = xs.map((x) => `M${x - 18} 0 L${x - 18} -200 L${x} -230 L${x + 18} -200 L${x + 18} 0 Z`).join(" ");
const side = xs.map((x) => `M${x + 6} 0 L${x + 6} -212 L${x} -230 L${x + 18} -200 L${x + 18} 0 Z`).join(" ");
return <g>
<rect x={-470} y={-170} width={940} height={26} fill={p.lo(wood, 0.35)} />
<rect x={-470} y={-70} width={940} height={26} fill={p.lo(wood, 0.35)} />
<path d={body} fill={p.c(wood)} />
<path d={side} fill={p.lo(wood, 0.36)} />
</g>;
},
bench: (p, color) => {
const wood = color ?? "#a0663e";
const iron = p.pal.ink;
return <g>
{[-200, 200].map((x) => <g key={x}>
<path d={`M${x - 16} 0 L${x - 10} -150 L${x + 10} -150 L${x + 16} 0 Z`} fill={p.c(mix(iron, "#555a66", 0.4))} />
<path d={`M${x - 6} -150 L${x - 2} -300 L${x + 14} -300 L${x + 10} -150 Z`} fill={p.c(mix(iron, "#555a66", 0.4))} />
</g>)}
<Box x={-260} y={-168} w={520} h={22} fill={wood} p={p} side={0.08} top={6} rx={5} />
<Box x={-260} y={-140} w={520} h={18} fill={mix(wood, "#000000", 0.1)} p={p} side={0.08} rx={5} />
{[-300, -250].map((y) => <Box key={y} x={-260} y={y} w={520} h={36} fill={wood} p={p} side={0.08} top={8} rx={6} />)}
<rect x={-260} y={-146} width={520} height={10} fill={p.lo(wood, 0.55)} opacity={0.7} />
</g>;
},
lamp: (p) => {
const pole = mix(p.pal.ink, "#4a5060", 0.35);
return <g>
{p.night && <path d="M-40 -780 L-260 0 L260 0 L40 -780 Z" fill={p.pal.light} opacity={0.07} />}
<rect x={-34} y={-60} width={68} height={60} rx={8} fill={p.c(pole)} />
<rect x={-12} y={-820} width={24} height={780} fill={p.c(pole)} /><rect x={2} y={-820} width={10} height={780} fill={p.lo(pole, 0.4)} />
<path d="M-56 -800 L56 -800 L40 -870 L-40 -870 Z" fill={p.c(p.night ? p.pal.light : mix(p.pal.sky[2], "#ffffff", 0.4))} />
<rect x={-64} y={-806} width={128} height={14} rx={5} fill={p.c(pole)} />
<path d="M-50 -870 L50 -870 L0 -904 Z" fill={p.c(pole)} /><path d="M0 -904 L50 -870 L20 -870 Z" fill={p.lo(pole, 0.4)} />
{p.night && <circle cx={0} cy={-836} r={90} fill={p.pal.light} opacity={0.12} />}
</g>;
},
gravestone: (p, color) => {
const s = color ?? p.pal.stone;
return <g>
<path d="M-110 0 L-110 -240 Q-110 -340 0 -340 Q110 -340 110 -240 L110 0 Z" fill={p.c(s)} />
<path d="M60 -330 Q110 -310 110 -240 L110 0 L68 0 L68 -240 Q68 -300 60 -330 Z" fill={p.lo(s, 0.38)} />
<path d="M-110 -240 Q-110 -330 -20 -340 Q-80 -320 -88 -240 Z" fill={p.hi(s, 0.2)} />
{[-230, -192, -156].map((y, i) => <rect key={y} x={-56 + i * 6} y={y} width={112 - i * 12} height={10} rx={5} fill={p.lo(s, 0.5)} />)}
<path d="M-130 0 Q-100 -30 -80 0 M90 0 Q110 -26 130 0" stroke={p.c(p.pal.leaf)} strokeWidth={10} fill="none" />
</g>;
},
cross: (p, color) => {
const s = color ?? p.pal.stone;
return <g>
<rect x={-24} y={-400} width={48} height={400} fill={p.c(s)} /><rect x={6} y={-400} width={18} height={400} fill={p.lo(s, 0.38)} />
<rect x={-120} y={-320} width={240} height={44} fill={p.c(s)} /><rect x={-120} y={-288} width={240} height={12} fill={p.lo(s, 0.45)} />
<rect x={-120} y={-320} width={240} height={8} fill={p.hi(s, 0.25)} />
</g>;
},
car: (p, color) => {
const c = color ?? "#c8443a";
const glass = mix(p.pal.sky[1], "#ffffff", 0.25);
return <g transform="scale(2.5)">
<path d="M-150 -40 L-150 -90 Q-140 -110 -100 -112 L-60 -160 L70 -160 L110 -112 L150 -100 L150 -40 Z" fill={p.c(c)} />
<path d="M-150 -74 L150 -74 L150 -40 L-150 -40 Z" fill={p.lo(c, 0.3)} />
<path d="M-100 -112 L-60 -160 L-40 -160 L-80 -112 Z" fill={p.hi(c, 0.25)} />
<path d="M-50 -150 L-4 -150 L-4 -114 L-78 -114 Z" fill={p.c(glass)} /><path d="M8 -150 L64 -150 L96 -114 L8 -114 Z" fill={p.lo(glass, 0.25)} />
<path d="M-30 -146 L-16 -146 L-34 -118 L-48 -118 Z" fill="#ffffff" opacity={0.5} />
<rect x={140} y={-96} width={12} height={14} rx={3} fill={p.c("#ffe6a0")} /><rect x={-152} y={-92} width={10} height={12} rx={3} fill={p.c("#e84a3a")} />
<rect x={-156} y={-48} width={312} height={10} rx={4} fill={p.lo(c, 0.5)} />
{[-90, 95].map((x) => <g key={x}><circle cx={x} cy={-35} r={32} fill={p.c("#1e1f26")} /><circle cx={x} cy={-35} r={15} fill={p.c("#9ea2ac")} /><circle cx={x + 4} cy={-33} r={8} fill={p.lo("#9ea2ac", 0.4)} /></g>)}
</g>;
},
sign: (p, color) => {
const c = color ?? "#2f6d3a";
return <g>
<rect x={-12} y={-440} width={24} height={440} fill={p.c(p.pal.ink)} /><rect x={2} y={-440} width={10} height={440} fill={p.lo(p.pal.ink, 0.3)} />
<rect x={-180} y={-540} width={360} height={150} rx={14} fill={p.c("#ffffff")} />
<rect x={-170} y={-530} width={340} height={130} rx={10} fill={p.c(c)} />
<rect x={-170} y={-430} width={340} height={30} rx={10} fill={p.lo(c, 0.3)} />
<rect x={-130} y={-500} width={200} height={14} rx={7} fill="#ffffff" opacity={0.55} /><rect x={-130} y={-472} width={140} height={14} rx={7} fill="#ffffff" opacity={0.4} />
</g>;
},
crate: (p, color) => {
const w = color ?? "#b0804a";
const dark = p.lo(w, 0.45);
return <g>
<polygon points="-130,-260 -92,-300 168,-300 130,-260" fill={p.hi(w, 0.25)} />
<polygon points="130,-260 168,-300 168,-38 130,0" fill={p.lo(w, 0.4)} />
<rect x={-130} y={-260} width={260} height={260} fill={p.c(w)} />
{[-195, -130, -65].map((y) => <rect key={y} x={-130} y={y} width={260} height={5} fill={dark} opacity={0.6} />)}
<path d="M-112 -242 L112 -18" stroke={p.c(mix(w, "#5a3a1a", 0.35))} strokeWidth={26} />
<path d="M-104 -250 L120 -26" stroke={dark} strokeWidth={6} />
<rect x={-130} y={-260} width={260} height={260} fill="none" stroke={p.c(mix(w, "#5a3a1a", 0.35))} strokeWidth={22} />
<rect x={108} y={-260} width={22} height={260} fill={dark} opacity={0.6} />
</g>;
},
tent: (p, color) => {
const c = color ?? "#d9773a";
return <g>
<path d="M-340 0 L0 -440 L340 0 Z" fill={p.c(c)} />
<path d="M0 -440 L340 0 L60 0 Z" fill={p.lo(c, 0.36)} />
<path d="M0 -440 L-340 0 L-300 0 Z" fill={p.hi(c, 0.25)} />
<path d="M-90 0 L0 -250 L90 0 Z" fill={p.c(mix(c, p.pal.ink, 0.75))} />
<path d="M0 -250 L-130 0 L-90 0 Z" fill={p.hi(c, 0.15)} />
<path d="M0 -440 L0 -480 M-340 0 L-420 -20 M340 0 L420 -20" stroke={p.c(p.pal.ink)} strokeWidth={6} />
</g>;
},
fire: (p) => <g>
<ellipse cx={0} cy={-8} rx={260} ry={40} fill={p.pal.light} opacity={0.22} />
<path d="M-110 -10 L100 -50 M-100 -50 L110 -10" stroke={p.c(p.pal.trunk)} strokeWidth={30} strokeLinecap="round" />
<path d="M-104 -16 L96 -54" stroke={p.lo(p.pal.trunk, 0.4)} strokeWidth={10} strokeLinecap="round" />
<path d="M-80 -30 Q-100 -150 -24 -230 Q-14 -150 34 -132 Q54 -210 18 -290 Q130 -200 86 -30 Z" fill="#e8562a" />
<path d="M-56 -32 Q-66 -120 -10 -180 Q0 -110 40 -100 Q54 -150 40 -200 Q100 -130 66 -32 Z" fill="#ff9a2a" />
<path d="M-24 -32 Q-34 -96 8 -130 Q16 -84 40 -76 Q48 -54 34 -32 Z" fill="#ffe066" />
</g>,
ark: (p, color) => {
// Arca: casco de tábuas com betume escuro embaixo, casa de um andar em cima com janelinhas e uma porta.
const wood = color ?? "#8a5a32";
const cabin = mix(wood, "#ffffff", 0.12);
return <g>
<path d="M-390 -150 L390 -150 Q362 -26 290 0 L-290 0 Q-362 -26 -390 -150 Z" fill={p.c(wood)} />
<path d="M-390 -150 L-340 -150 Q-330 -40 -270 0 L-290 0 Q-362 -26 -390 -150 Z" fill={p.hi(wood, 0.2)} />
<path d="M180 -150 L390 -150 Q362 -26 290 0 L160 0 Q200 -60 180 -150 Z" fill={p.lo(wood, 0.3)} />
<path d="M-370 -60 Q-330 -6 -290 0 L290 0 Q330 -6 370 -60 Z" fill={p.c("#3a2a22")} opacity={0.8} />
{[-120, -92, -64, -36].map((y) => <path key={y} d={`M${-386 + (y + 150) * 0.2} ${y} L${386 - (y + 150) * 0.2} ${y}`} stroke={p.lo(wood, 0.5)} strokeWidth={5} opacity={0.7} />)}
<rect x={-400} y={-162} width={800} height={18} rx={6} fill={p.hi(mix(wood, "#6b4426", 0.5), 0.2)} />
<rect x={-230} y={-290} width={460} height={130} fill={p.c(cabin)} />
<rect x={150} y={-290} width={80} height={130} fill={p.lo(cabin, 0.32)} />
{[-180, -110, -40, 30, 100].map((x) => <rect key={x} x={x} y={-262} width={34} height={26} rx={3} fill={p.c(mix(p.pal.ink, wood, 0.3))} />)}
<rect x={160} y={-224} width={56} height={64} rx={4} fill={p.lo("#4a2f1c", 0.3)} />
<polygon points="-262,-288 0,-352 262,-288" fill={p.c("#6a4428")} />
<polygon points="0,-352 262,-288 120,-288" fill={p.lo("#6a4428", 0.35)} />
</g>;
},
ark_frame: (p, color) => {
// Arca em construção: quilha, costelas curvas de madeira clara e só as primeiras fileiras de tábuas.
const wood = color ?? "#c9955a";
return <g>
<rect x={-380} y={-26} width={760} height={26} rx={6} fill={p.c("#7a5232")} />
{Array.from({ length: 11 }, (_, i) => {
const x = -330 + i * 66;
const k = 1 - Math.abs(x) / 420;
const d = `M${x} -20 Q${x * 1.02} ${-110 - k * 40} ${x * 1.14} ${-170 - k * 30}`;
return <g key={i}><path d={d} stroke={p.c(wood)} strokeWidth={16} fill="none" strokeLinecap="round" />
<path d={d} transform="translate(5 0)" stroke={p.lo(wood, 0.35)} strokeWidth={6} fill="none" strokeLinecap="round" /></g>;
})}
<path d="M-360 -60 Q-320 -12 -280 -14 L280 -14 Q320 -12 360 -60 L340 -92 Q300 -54 270 -56 L-270 -56 Q-300 -54 -340 -92 Z" fill={p.c("#8a5a32")} />
<path d="M-300 -34 L300 -34" stroke={p.lo("#8a5a32", 0.5)} strokeWidth={5} />
<rect x={-390} y={-200} width={780} height={12} rx={5} fill={p.c(wood)} />
<rect x={-390} y={-192} width={780} height={4} rx={2} fill={p.lo(wood, 0.4)} />
</g>;
},
scaffold: (p, color) => {
const wood = color ?? "#a87a48";
return <g strokeLinecap="round">
<path d="M-110 0 L-110 -330 M110 0 L110 -330" strokeWidth={14} stroke={p.c(wood)} />
<path d="M-104 0 L-104 -330 M116 0 L116 -330" strokeWidth={5} stroke={p.lo(wood, 0.4)} />
<path d="M-130 -120 L130 -120 M-130 -240 L130 -240" strokeWidth={18} stroke={p.c("#7a5232")} />
<path d="M-130 -114 L130 -114 M-130 -234 L130 -234" strokeWidth={6} stroke={p.lo("#7a5232", 0.4)} />
<path d="M-110 -10 L110 -120 M110 -130 L-110 -240" strokeWidth={8} stroke={p.c(wood)} opacity={0.85} />
</g>;
},
planks: (p, color) => {
const w = color ?? "#c9955a";
return <g>{[0, 1, 2, 3].map((i) => <Box key={i} x={-170 + (i % 2) * 22} y={-26 - i * 22} w={340 - i * 14} h={20} fill={i % 2 ? w : mix(w, "#000000", 0.12)} p={p} side={0.1} top={5} rx={4} />)}</g>;
},
};
/**
* Parte da FRENTE das peças que podem ter gente dentro (casco e amurada da arca; lataria abaixo das janelas do
* carro). Com `occupied: true` no lugar, ela é desenhada de novo POR CIMA dos personagens: eles ficam "dentro".
*/
export const FRONT_PART: Record<string, Draw> = {
ark: (p, color) => {
const wood = color ?? "#8a5a32";
return <g>
<path d="M-390 -150 L390 -150 Q362 -26 290 0 L-290 0 Q-362 -26 -390 -150 Z" fill={p.c(wood)} />
<path d="M-390 -150 L-340 -150 Q-330 -40 -270 0 L-290 0 Q-362 -26 -390 -150 Z" fill={p.hi(wood, 0.2)} />
<path d="M180 -150 L390 -150 Q362 -26 290 0 L160 0 Q200 -60 180 -150 Z" fill={p.lo(wood, 0.3)} />
<path d="M-370 -60 Q-330 -6 -290 0 L290 0 Q330 -6 370 -60 Z" fill={p.c("#3a2a22")} opacity={0.8} />
{[-120, -92, -64, -36].map((y) => <path key={y} d={`M${-386 + (y + 150) * 0.2} ${y} L${386 - (y + 150) * 0.2} ${y}`} stroke={p.lo(wood, 0.5)} strokeWidth={5} opacity={0.7} />)}
<rect x={-400} y={-162} width={800} height={18} rx={6} fill={p.hi(mix(wood, "#6b4426", 0.5), 0.2)} />
</g>;
},
car: (p, color) => {
const c = color ?? "#c8443a";
return <g transform="scale(2.5)">
<path d="M-150 -40 L-150 -90 Q-140 -110 -100 -112 L150 -100 L150 -40 Z" fill={p.c(c)} />
<path d="M-150 -74 L150 -74 L150 -40 L-150 -40 Z" fill={p.lo(c, 0.3)} />
<rect x={140} y={-96} width={12} height={14} rx={3} fill={p.c("#ffe6a0")} /><rect x={-152} y={-92} width={10} height={12} rx={3} fill={p.c("#e84a3a")} />
<rect x={-156} y={-48} width={312} height={10} rx={4} fill={p.lo(c, 0.5)} />
{[-90, 95].map((x) => <g key={x}><circle cx={x} cy={-35} r={32} fill={p.c("#1e1f26")} /><circle cx={x} cy={-35} r={15} fill={p.c("#9ea2ac")} /><circle cx={x + 4} cy={-33} r={8} fill={p.lo("#9ea2ac", 0.4)} /></g>)}
</g>;
},
};
+343
View File
@@ -0,0 +1,343 @@
// Peças de interior: porta, janela, mesa, cama, estante, arquivo, armários de metal, quadro, luminárias, escrivaninha,
// varal. Base em (0,0) no chão; as de parede (janela, quadro, varal) já desenham na altura certa acima do chão; a
// luminária pendente tem a origem no TETO (y cresce para baixo). Luz da esquerda.
import React from "react";
import { mix, type Paint } from "./paint";
import { Box } from "./built";
import type { Draw } from "./nature";
const BOOKS = ["#c8483a", "#e0a63a", "#3f78b8", "#4f9a6a", "#e8e0cc", "#7a4a8a", "#2f4a6a", "#b86a3a"];
const CLOTHES = ["#4f9a5a", "#e2b33a", "#c8483a", "#3f6aa8", "#e8e2d6", "#7f9a5a", "#8a5ab0"];
/** Taça de troféu (dourada), base no chão da prateleira. */
function Trophy({ x, y, s, p }: { x: number; y: number; s: number; p: Paint }) {
const g = "#d6a536";
return <g transform={`translate(${x} ${y}) scale(${s})`}>
<rect x={-24} y={-14} width={48} height={14} rx={2} fill={p.c(mix(g, "#5a4020", 0.4))} />
<rect x={-6} y={-40} width={12} height={28} fill={p.c(g)} />
<path d="M-34 -100 L34 -100 Q32 -52 0 -40 Q-32 -52 -34 -100 Z" fill={p.c(g)} />
<path d="M6 -100 L34 -100 Q32 -52 0 -40 Q14 -60 6 -100 Z" fill={p.lo(g, 0.38)} />
<path d="M-34 -92 Q-56 -88 -48 -70 Q-42 -60 -26 -62 M34 -92 Q56 -88 48 -70 Q42 -60 26 -62" stroke={p.c(g)} strokeWidth={6} fill="none" />
<rect x={-26} y={-96} width={8} height={30} rx={4} fill={p.hi(g, 0.5)} />
</g>;
}
/** O que vai numa prateleira (sorteado pela semente): livros, troféu, potes/caixas ou planta. */
function ShelfItems({ x0, x1, y, h, p }: { x0: number; x1: number; y: number; h: number; p: Paint }) {
const kind = p.r();
if (kind < 0.18) return <Trophy x={(x0 + x1) / 2 + (p.r() - 0.5) * 80} y={y} s={h / 110} p={p} />;
if (kind < 0.3) {
return <g>{[0, 1, 2].map((i) => {
const c = BOOKS[Math.floor(p.r() * BOOKS.length)];
const w = 60 + p.r() * 30;
const hh = h * (0.4 + p.r() * 0.35);
const x = x0 + 14 + i * ((x1 - x0) / 3);
return <g key={i}><rect x={x} y={y - hh} width={w} height={hh} rx={6} fill={p.c(c)} /><rect x={x + w * 0.7} y={y - hh} width={w * 0.3} height={hh} rx={4} fill={p.lo(c, 0.35)} /></g>;
})}</g>;
}
if (kind < 0.38) {
const pot = "#c0704a";
const cx = (x0 + x1) / 2;
return <g>
<path d={`M${cx - 40} ${y - 60} L${cx + 40} ${y - 60} L${cx + 30} ${y} L${cx - 30} ${y} Z`} fill={p.c(pot)} />
<path d={`M${cx + 10} ${y - 60} L${cx + 40} ${y - 60} L${cx + 30} ${y} L${cx + 8} ${y} Z`} fill={p.lo(pot, 0.35)} />
{[-50, -15, 20, 50].map((dx, i) => <ellipse key={i} cx={cx + dx} cy={y - 70 - (i % 2) * 30} rx={22} ry={44} transform={`rotate(${dx / 2} ${cx + dx} ${y - 70})`} fill={i % 2 ? p.lo(p.pal.leaf, 0.3) : p.c(p.pal.leaf)} />)}
</g>;
}
// Livros em pé, de alturas e cores variadas (às vezes um deitado no fim da fileira).
const books: React.ReactNode[] = [];
let x = x0 + 6;
while (x < x1 - 30) {
const w = 18 + p.r() * 16;
const hh = h * (0.62 + p.r() * 0.32);
const c = BOOKS[Math.floor(p.r() * BOOKS.length)];
books.push(<g key={x}><rect x={x} y={y - hh} width={w} height={hh} rx={2} fill={p.c(c)} /><rect x={x + w * 0.62} y={y - hh} width={w * 0.38} height={hh} fill={p.lo(c, 0.35)} />
<rect x={x} y={y - hh * 0.8} width={w} height={4} fill={p.hi(c, 0.4)} /></g>);
x += w + 2;
if (p.r() < 0.12) x += 24;
}
return <g>{books}</g>;
}
export const INDOOR: Record<string, Draw> = {
door: (p, color) => {
const d = color ?? "#6e4a30";
const trim = mix(p.pal.wall, "#f4ece0", 0.55);
return <g>
<rect x={-172} y={-664} width={344} height={664} rx={6} fill={p.c(trim)} />
<rect x={140} y={-664} width={32} height={664} fill={p.lo(trim, 0.3)} />
<rect x={-150} y={-640} width={300} height={640} fill={p.c(d)} />
<rect x={110} y={-640} width={40} height={640} fill={p.lo(d, 0.35)} />
{[[-600, 250], [-320, 270]].map(([y, h]) => <g key={y}>
<rect x={-112} y={y} width={200} height={h} rx={4} fill={p.lo(d, 0.16)} />
<rect x={-112} y={y} width={12} height={h} fill={p.lo(d, 0.42)} /><rect x={-112} y={y} width={200} height={10} fill={p.lo(d, 0.42)} />
<rect x={76} y={y} width={12} height={h} fill={p.hi(d, 0.25)} /><rect x={-112} y={y + h - 10} width={200} height={10} fill={p.hi(d, 0.25)} />
</g>)}
<rect x={96} y={-350} width={22} height={70} rx={8} fill={p.c("#c9a560")} />
<circle cx={107} cy={-316} r={12} fill={p.hi("#e6c27a", 0.3)} />
</g>;
},
window: (p, color) => {
// Janela na parede: moldura, céu lá fora (claro de dia, escuro com lua à noite), copa de árvore, cortinas.
const trim = mix(p.pal.wall, "#f4ece0", 0.6);
const out = color ?? (p.night ? "#1c2a5a" : mix(p.pal.sky[2], "#ffffff", 0.25));
const outTop = p.night ? "#121c44" : mix(p.pal.sky[1], "#ffffff", 0.2);
const curtain = p.r() > 0.45 ? ["#b8483a", "#3f6aa8", "#c89a3a", "#6a8a4a"][Math.floor(p.r() * 4)] : null;
return <g>
<rect x={-210} y={-640} width={420} height={420} rx={6} fill={p.c(trim)} />
<rect x={180} y={-640} width={30} height={420} fill={p.lo(trim, 0.3)} />
<rect x={-186} y={-616} width={372} height={372} fill={p.c(out)} />
<rect x={-186} y={-616} width={372} height={170} fill={p.c(outTop)} />
{p.night && <circle cx={-90} cy={-540} r={30} fill={p.c("#f4ecc8")} />}
<g fill={p.night ? p.c("#1a3040") : p.c(mix(p.pal.leaf, out, 0.35))}>
<circle cx={-140} cy={-300} r={90} /><circle cx={-40} cy={-280} r={70} /><circle cx={120} cy={-290} r={80} /><circle cx={-170} cy={-380} r={60} />
</g>
<path d="M-120 -616 L-40 -616 L-186 -380 L-186 -510 Z" fill="#ffffff" opacity={0.14} />
<rect x={-8} y={-616} width={16} height={372} fill={p.c(trim)} /><rect x={-186} y={-438} width={372} height={16} fill={p.c(trim)} />
<rect x={2} y={-616} width={6} height={372} fill={p.lo(trim, 0.3)} />
<rect x={-232} y={-236} width={464} height={26} rx={5} fill={p.hi(trim, 0.2)} />
<rect x={-224} y={-210} width={448} height={14} fill={p.lo(p.pal.wall, 0.45)} opacity={0.7} />
{curtain && [-1, 1].map((s) => <g key={s}>
<path d={`M${s * 190} -666 L${s * 270} -666 L${s * 290} -200 L${s * 200} -200 Q${s * 214} -440 ${s * 190} -666 Z`} fill={p.c(curtain)} />
<path d={`M${s * 236} -666 L${s * 270} -666 L${s * 290} -200 L${s * 250} -200 Z`} fill={s > 0 ? p.lo(curtain, 0.35) : p.hi(curtain, 0.18)} />
<path d={`M${s * 214} -640 L${s * 224} -210`} stroke={p.lo(curtain, 0.3)} strokeWidth={6} />
</g>)}
{curtain && <rect x={-300} y={-680} width={600} height={16} rx={8} fill={p.c(mix(p.pal.trunk, "#8a6a4a", 0.3))} />}
</g>;
},
table: (p, color) => {
const w = color ?? "#9a643c";
return <g>
{[-236, 220].map((x) => <rect key={x} x={x} y={-300} width={18} height={270} fill={p.lo(w, 0.5)} />)}
<polygon points="-280,-270 280,-270 250,-304 -250,-304" fill={p.hi(w, 0.22)} />
<rect x={-280} y={-270} width={560} height={28} fill={p.c(w)} />
<rect x={-280} y={-248} width={560} height={6} fill={p.lo(w, 0.45)} />
<rect x={236} y={-270} width={44} height={28} fill={p.lo(w, 0.32)} />
{[-262, 236].map((x) => <g key={x}><rect x={x} y={-242} width={26} height={242} fill={p.c(w)} /><rect x={x + 14} y={-242} width={12} height={242} fill={p.lo(w, 0.38)} /></g>)}
</g>;
},
bed: (p, color) => {
const blanket = color ?? "#4f64a8";
const wood = mix(p.pal.trunk, "#9a6a40", 0.4);
const sheet = "#ecebe6";
return <g>
<path d="M-390 0 L-390 -330 Q-390 -380 -350 -380 Q-320 -380 -320 -330 L-320 0 Z" fill={p.c(wood)} />
<rect x={-340} y={-380} width={20} height={380} fill={p.lo(wood, 0.35)} />
<rect x={-330} y={-118} width={680} height={50} fill={p.c(wood)} /><rect x={-330} y={-80} width={680} height={12} fill={p.lo(wood, 0.4)} />
<rect x={-320} y={-210} width={660} height={96} rx={18} fill={p.c(sheet)} />
<rect x={-312} y={-262} width={160} height={64} rx={28} fill={p.hi(sheet, 0.2)} />
<path d="M-180 -262 Q-160 -230 -168 -200" stroke={p.lo(sheet, 0.3)} strokeWidth={6} fill="none" />
<path d="M-120 -222 Q100 -238 344 -214 L350 -96 Q120 -88 -120 -100 Z" fill={p.c(blanket)} />
<path d="M-120 -222 Q100 -238 344 -214 L344 -196 Q100 -214 -120 -204 Z" fill={p.hi(blanket, 0.25)} />
<path d="M0 -224 Q20 -160 -10 -100 M150 -228 Q180 -170 160 -94" stroke={p.lo(blanket, 0.35)} strokeWidth={10} fill="none" strokeLinecap="round" />
<rect x={300} y={-216} width={50} height={120} fill={p.lo(blanket, 0.3)} />
<rect x={340} y={-260} width={36} height={260} rx={6} fill={p.c(wood)} /><rect x={360} y={-260} width={16} height={260} fill={p.lo(wood, 0.4)} />
{[-310, 320].map((x) => <rect key={x} x={x} y={-70} width={22} height={70} fill={p.lo(wood, 0.3)} />)}
</g>;
},
shelf: (p, color) => {
const w = color ?? mix(p.pal.trunk, "#8a5a36", 0.4);
const back = p.lo(w, 0.55);
const ys = [-616, -466, -316, -166];
return <g>
<polygon points="200,0 200,-640 236,-664 236,-16" fill={p.lo(w, 0.42)} />
<rect x={-200} y={-640} width={400} height={640} fill={p.c(w)} />
<rect x={-176} y={-616} width={352} height={590} fill={back} />
{ys.map((y) => <g key={y}>
<rect x={-176} y={y + 122} width={352} height={14} fill={p.lo(w, 0.7)} opacity={0.5} />
<ShelfItems x0={-170} x1={170} y={y + 128} h={118} p={p} />
<rect x={-180} y={y + 128} width={360} height={22} fill={p.c(w)} />
<rect x={-180} y={y + 128} width={360} height={6} fill={p.hi(w, 0.3)} />
</g>)}
<rect x={-200} y={-640} width={24} height={640} fill={p.hi(w, 0.14)} />
<rect x={176} y={-640} width={24} height={640} fill={p.lo(w, 0.25)} />
<rect x={-214} y={-664} width={428} height={28} rx={4} fill={p.hi(w, 0.18)} />
<polygon points="214,-664 250,-686 250,-662 214,-636" fill={p.lo(w, 0.5)} />
</g>;
},
cabinet: (p, color) => {
// Arquivo/armário de gavetas.
const m = color ?? "#6f7f8a";
return <g>
<polygon points="150,0 150,-560 192,-584 192,-18" fill={p.lo(m, 0.42)} />
<polygon points="-150,-560 -108,-584 192,-584 150,-560" fill={p.hi(m, 0.3)} />
<rect x={-150} y={-560} width={300} height={560} fill={p.c(m)} />
{[0, 1, 2, 3].map((i) => {
const y = -540 + i * 132;
return <g key={i}>
<rect x={-130} y={y} width={260} height={118} rx={5} fill={p.c(mix(m, "#ffffff", 0.06))} />
<rect x={-130} y={y + 108} width={260} height={10} fill={p.lo(m, 0.4)} />
<rect x={-130} y={y} width={260} height={6} fill={p.hi(m, 0.25)} />
<rect x={-34} y={y + 26} width={68} height={26} rx={3} fill={p.c("#ece6d4")} />
<rect x={-46} y={y + 64} width={92} height={16} rx={8} fill={p.lo(m, 0.55)} />
<rect x={-46} y={y + 64} width={92} height={6} rx={3} fill={p.hi(m, 0.4)} />
</g>;
})}
<rect x={118} y={-560} width={32} height={560} fill={p.lo(m, 0.25)} />
</g>;
},
locker: (p, color) => {
// Fileira de 3 armários de metal (vestiário, escola, fábrica).
const m = color ?? "#3f5f8c";
return <g>
<polygon points="300,0 300,-760 340,-784 340,-20" fill={p.lo(m, 0.45)} />
<polygon points="-300,-760 -260,-784 340,-784 300,-760" fill={p.hi(m, 0.25)} />
<rect x={-300} y={-760} width={600} height={760} fill={p.lo(m, 0.3)} />
{[-1, 0, 1].map((k) => {
const x = k * 198 - 96;
return <g key={k}>
<rect x={x} y={-744} width={192} height={680} rx={4} fill={p.c(m)} />
<rect x={x + 160} y={-744} width={32} height={680} fill={p.lo(m, 0.28)} />
<rect x={x} y={-744} width={192} height={6} fill={p.hi(m, 0.3)} />
{[0, 1, 2, 3].map((i) => <rect key={i} x={x + 36} y={-700 + i * 26} width={110} height={12} rx={6} fill={p.lo(m, 0.55)} />)}
{[0, 1, 2].map((i) => <rect key={i} x={x + 36} y={-150 + i * 26} width={110} height={12} rx={6} fill={p.lo(m, 0.55)} />)}
<rect x={x + 150} y={-430} width={16} height={86} rx={8} fill={p.hi(m, 0.4)} />
<rect x={x + 60} y={-560} width={56} height={34} rx={4} fill={p.c("#ece6d4")} opacity={0.85} />
</g>;
})}
<rect x={-300} y={-64} width={600} height={64} fill={p.lo(m, 0.5)} />
</g>;
},
frame: (p, color) => {
// Quadro na parede (paisagem, foto de grupo, retrato ou abstrato).
const f = color ?? "#9a6a3a";
const kind = Math.floor(p.r() * 4);
const x = -170;
const y = -700;
const w = 340;
const h = 260;
const ix = x + 26;
const iy = y + 26;
const iw = w - 52;
const ih = h - 52;
const sepia = mix("#d8c8a0", p.pal.wall, 0.15);
const pic: React.ReactNode =
kind === 0 ? <g>
<rect x={ix} y={iy} width={iw} height={ih} fill={p.c(mix(p.pal.sky[1], "#ffffff", 0.3))} />
<circle cx={ix + iw * 0.25} cy={iy + ih * 0.3} r={22} fill={p.c("#ffe08a")} />
<path d={`M${ix} ${iy + ih} L${ix} ${iy + ih * 0.62} Q${ix + iw * 0.3} ${iy + ih * 0.4} ${ix + iw * 0.55} ${iy + ih * 0.62} Q${ix + iw * 0.8} ${iy + ih * 0.45} ${ix + iw} ${iy + ih * 0.6} L${ix + iw} ${iy + ih} Z`} fill={p.c("#6a9a5a")} />
<path d={`M${ix + iw * 0.55} ${iy + ih * 0.62} Q${ix + iw * 0.8} ${iy + ih * 0.45} ${ix + iw} ${iy + ih * 0.6} L${ix + iw} ${iy + ih} L${ix + iw * 0.5} ${iy + ih} Z`} fill={p.lo("#6a9a5a", 0.3)} />
</g>
: kind === 1 ? <g>
<rect x={ix} y={iy} width={iw} height={ih} fill={p.c(sepia)} />
{[0, 1, 2, 3, 4].map((i) => {
const cx = ix + 40 + i * ((iw - 80) / 4);
return <g key={i} fill={p.lo(sepia, 0.55)}><circle cx={cx} cy={iy + ih * 0.42} r={17} /><rect x={cx - 24} y={iy + ih * 0.42 + 18} width={48} height={ih * 0.4} rx={14} /></g>;
})}
<rect x={ix} y={iy + ih * 0.86} width={iw} height={ih * 0.14} fill={p.lo(sepia, 0.3)} />
</g>
: kind === 2 ? <g>
<rect x={ix} y={iy} width={iw} height={ih} fill={p.c("#c8b490")} />
<circle cx={ix + iw / 2} cy={iy + ih * 0.42} r={40} fill={p.lo("#c8b490", 0.5)} />
<path d={`M${ix + iw / 2 - 80} ${iy + ih} Q${ix + iw / 2} ${iy + ih * 0.55} ${ix + iw / 2 + 80} ${iy + ih} Z`} fill={p.lo("#c8b490", 0.5)} />
</g>
: <g>
<rect x={ix} y={iy} width={iw} height={ih} fill={p.c("#ece2cc")} />
<rect x={ix + 20} y={iy + 20} width={iw * 0.45} height={ih * 0.5} fill={p.c("#c8483a")} />
<rect x={ix + iw * 0.55} y={iy + ih * 0.35} width={iw * 0.35} height={ih * 0.5} fill={p.c("#3f6aa8")} />
<circle cx={ix + iw * 0.4} cy={iy + ih * 0.7} r={30} fill={p.c("#e2b33a")} />
</g>;
return <g>
<rect x={x + 14} y={y + 16} width={w} height={h} rx={4} fill={p.pal.ink} opacity={0.22} />
<rect x={x} y={y} width={w} height={h} rx={4} fill={p.c(f)} />
<rect x={x} y={y} width={w} height={10} fill={p.hi(f, 0.3)} /><rect x={x} y={y} width={10} height={h} fill={p.hi(f, 0.3)} />
<rect x={x + w - 12} y={y} width={12} height={h} fill={p.lo(f, 0.38)} /><rect x={x} y={y + h - 12} width={w} height={12} fill={p.lo(f, 0.38)} />
{pic}
<rect x={ix} y={iy} width={iw} height={8} fill={p.pal.ink} opacity={0.2} /><rect x={ix} y={iy} width={8} height={ih} fill={p.pal.ink} opacity={0.15} />
</g>;
},
pendant: (p, color) => {
// Luminária pendente: origem no teto, fio descendo, cúpula e a lâmpada acesa por baixo.
const s = color ?? "#2f3f6a";
return <g>
<rect x={-3} y={-20} width={6} height={290} fill={p.c(p.pal.ink)} />
<rect x={-18} y={250} width={36} height={24} rx={4} fill={p.c(mix(s, p.pal.ink, 0.3))} />
<circle cx={0} cy={372} r={150} fill={p.pal.light} opacity={0.14} />
<path d="M-130 370 Q-124 272 0 266 Q124 272 130 370 Z" fill={p.c(s)} />
<path d="M30 268 Q124 274 130 370 L60 370 Q66 300 30 268 Z" fill={p.lo(s, 0.38)} />
<path d="M-104 352 Q-104 296 -40 276 Q-84 300 -84 352 Z" fill={p.hi(s, 0.3)} />
<ellipse cx={0} cy={370} rx={130} ry={20} fill={p.pal.light} />
<ellipse cx={0} cy={376} rx={44} ry={24} fill="#fffbe8" />
</g>;
},
desklamp: (p, color) => {
// Luminária de mesa articulada, acesa (poça de luz na base). Fica em cima de mesa/escrivaninha próxima.
const m = color ?? "#5f7a4a";
return <g>
<path d="M40 -250 L240 0 L-40 0 L-10 -230 Z" fill={p.pal.light} opacity={0.16} />
<ellipse cx={100} cy={-4} rx={150} ry={22} fill={p.pal.light} opacity={0.3} />
<ellipse cx={-60} cy={-12} rx={70} ry={16} fill={p.c(m)} /><rect x={-130} y={-12} width={140} height={12} fill={p.lo(m, 0.35)} />
<path d="M-60 -16 L-100 -200 M-100 -200 L20 -300" stroke={p.c(m)} strokeWidth={18} strokeLinecap="round" fill="none" />
<path d="M-54 -18 L-94 -198" stroke={p.lo(m, 0.4)} strokeWidth={6} strokeLinecap="round" />
<circle cx={-100} cy={-200} r={16} fill={p.lo(m, 0.3)} />
<g transform="translate(20 -300) rotate(35)">
<path d="M-30 -30 L30 -30 L80 60 L-80 60 Z" fill={p.c(m)} />
<path d="M10 -30 L30 -30 L80 60 L40 60 Z" fill={p.lo(m, 0.4)} />
<ellipse cx={0} cy={60} rx={80} ry={14} fill={p.pal.light} />
<ellipse cx={0} cy={62} rx={30} ry={10} fill="#fffbe8" />
</g>
</g>;
},
desk: (p, color) => {
// Escrivaninha de 2 gaveteiros, com papéis, livros e caneca por cima.
const w = color ?? "#8a5a36";
const knob = "#d8b060";
return <g>
<rect x={-110} y={-276} width={220} height={236} fill={p.lo(w, 0.62)} />
{[-310, 110].map((x) => <g key={x}>
<rect x={x} y={-276} width={200} height={276} fill={p.c(w)} />
<rect x={x + 170} y={-276} width={30} height={276} fill={p.lo(w, 0.3)} />
{[0, 1, 2].map((i) => <g key={i}>
<rect x={x + 14} y={-262 + i * 86} width={172} height={74} rx={4} fill={p.c(mix(w, "#ffffff", 0.05))} />
<rect x={x + 14} y={-196 + i * 86} width={172} height={8} fill={p.lo(w, 0.45)} />
<circle cx={x + 100} cy={-226 + i * 86} r={11} fill={p.hi(knob, 0.2)} /><circle cx={x + 104} cy={-223 + i * 86} r={5} fill={p.lo(knob, 0.4)} />
</g>)}
</g>)}
<polygon points="-330,-300 330,-300 304,-330 -304,-330" fill={p.hi(w, 0.22)} />
<rect x={-330} y={-300} width={660} height={26} fill={p.c(w)} /><rect x={-330} y={-280} width={660} height={6} fill={p.lo(w, 0.5)} />
<rect x={290} y={-300} width={40} height={26} fill={p.lo(w, 0.32)} />
<g transform={`translate(${p.r() > 0.5 ? 90 : -230} -312)`}>
{[0, 1, 2].map((i) => <rect key={i} x={i * 4} y={-i * 7} width={130} height={8} rx={2} fill={p.c(i % 2 ? "#f2eee4" : "#e2dccc")} />)}
</g>
<g transform="translate(200 -312)">
<rect x={0} y={-30} width={100} height={30} rx={3} fill={p.c("#3f6aa8")} /><rect x={6} y={-54} width={90} height={24} rx={3} fill={p.c("#c8483a")} />
<rect x={70} y={-30} width={30} height={30} fill={p.lo("#3f6aa8", 0.35)} />
</g>
<g transform="translate(-90 -312)">
<rect x={-22} y={-48} width={44} height={48} rx={6} fill={p.c("#ece6d8")} /><rect x={6} y={-48} width={16} height={48} fill={p.lo("#ece6d8", 0.3)} />
<path d="M22 -38 Q42 -30 22 -14" stroke={p.c("#ece6d8")} strokeWidth={7} fill="none" />
</g>
</g>;
},
clothesline: (p, color) => {
// Varal: corda com roupas presas. Ao ar livre tem dois postes; dentro de casa fica preso na parede.
const rope = mix(p.pal.trunk, "#c8b08a", 0.5);
// Dentro de casa a corda vai de parede a parede (mais alta e mais comprida, sem postes).
const y0 = p.indoor ? -880 : -720;
const half = p.indoor ? 720 : 500;
const yAt = (t: number) => y0 + 120 * t * (1 - t);
const items = p.indoor ? [0.12, 0.25, 0.38, 0.51, 0.64, 0.77, 0.9] : [0.1, 0.26, 0.42, 0.58, 0.74, 0.9];
return <g>
{!p.indoor && [-500, 500].map((x) => <g key={x}><rect x={x - 14} y={-760} width={28} height={760} fill={p.c(p.pal.trunk)} /><rect x={x + 2} y={-760} width={12} height={760} fill={p.lo(p.pal.trunk, 0.4)} /></g>)}
<path d={`M${-half} ${y0} Q0 ${y0 + 120} ${half} ${y0}`} stroke={p.c(rope)} strokeWidth={6} fill="none" />
{items.map((t, i) => {
const x = -half + 2 * half * t;
const y = yAt(t);
const c = color && i % 2 === 0 ? color : CLOTHES[Math.floor(p.r() * CLOTHES.length)];
const towel = p.r() < 0.3;
const tilt = (t - 0.5) * 10;
return <g key={i} transform={`translate(${x} ${y - 4}) rotate(${tilt})`}>
{towel
? <g><rect x={-46} y={0} width={92} height={150} rx={4} fill={p.c(c)} /><rect x={18} y={0} width={28} height={150} fill={p.lo(c, 0.35)} />
<rect x={-46} y={120} width={92} height={10} fill={p.hi(c, 0.4)} /></g>
: <g>
<path d="M-40 0 L-86 26 L-68 64 L-46 54 L-46 168 L46 168 L46 54 L68 64 L86 26 L40 0 Q0 18 -40 0 Z" fill={p.c(c)} />
<path d="M14 8 L40 0 L86 26 L68 64 L46 54 L46 168 L14 168 Z" fill={p.lo(c, 0.35)} />
<path d="M-40 0 Q0 18 40 0 L28 -2 Q0 10 -28 -2 Z" fill={p.hi(c, 0.5)} />
</g>}
<rect x={-30} y={-12} width={10} height={22} rx={2} fill={p.c("#c8a070")} /><rect x={20} y={-12} width={10} height={22} rx={2} fill={p.c("#c8a070")} />
</g>;
})}
</g>;
},
};
+142
View File
@@ -0,0 +1,142 @@
// Peças da natureza: árvores, mato, pedras, montanha, nuvem, palmeira, ondas. Base em (0,0); luz da esquerda.
import React from "react";
import { mix, type Paint } from "./paint";
export type Draw = (p: Paint, color?: string) => React.ReactNode;
type Blob = [number, number, number];
/** Copa/moita/nuvem em 2 tons: tudo na cor da sombra, a parte de cima-esquerda na base e brilho nos topos. */
export function Foliage({ blobs, color, p, shadeK = 0.5, hiK = 0.14, lift = 0.16 }: { blobs: Blob[]; color: string; p: Paint; shadeK?: number; hiK?: number; lift?: number }) {
const cx = blobs.reduce((s, b) => s + b[0], 0) / blobs.length;
const cy = blobs.reduce((s, b) => s + b[1], 0) / blobs.length;
const top = Math.min(...blobs.map((b) => b[1] - b[2]));
return (
<g>
<g fill={p.lo(color, shadeK)}>{blobs.map(([x, y, r], i) => <circle key={i} cx={x} cy={y} r={r} />)}</g>
<g fill={p.c(color)}>{blobs.map(([x, y, r], i) => <circle key={i} cx={x - r * lift * 0.8} cy={y - r * lift} r={r * 0.8} />)}</g>
{hiK > 0 && <g fill={p.hi(color, hiK)}>
{blobs.filter(([x, y, r]) => x <= cx + 40 && y - r <= top + (cy - top) * 0.5).map(([x, y, r], i) => <circle key={i} cx={x - r * 0.24} cy={y - r * 0.3} r={r * 0.6} />)}
</g>}
</g>
);
}
const jitter = (p: Paint, blobs: Blob[], k = 1): Blob[] => blobs.map(([x, y, s]) => [x + (p.r() - 0.5) * 36 * k, y + (p.r() - 0.5) * 28 * k, s * (0.9 + p.r() * 0.2)]);
export const NATURE: Record<string, Draw> = {
tree: (p, color) => {
const leaf = color ?? p.pal.leaf;
const bark = p.pal.trunk;
const blobs = jitter(p, [[-210, -560, 150], [205, -575, 150], [0, -520, 170], [-100, -700, 175], [120, -710, 170], [5, -840, 150],
[-285, -660, 110], [285, -670, 105], [0, -660, 200]]);
return <g>
<path d="M-56 0 Q-30 -10 -30 -200 L-28 -400 L28 -400 Q30 -200 32 -10 Q50 0 62 0 Z" fill={p.c(bark)} />
<path d="M6 -2 Q20 -150 16 -400 L28 -400 Q30 -200 32 -10 Q50 0 62 0 Z" fill={p.lo(bark, 0.4)} />
<path d="M-12 -330 Q-90 -420 -170 -520 M8 -360 Q70 -460 150 -560 M0 -380 L-6 -560" stroke={p.c(bark)} strokeWidth={30} strokeLinecap="round" fill="none" />
<path d="M14 -364 Q76 -456 156 -552" stroke={p.lo(bark, 0.4)} strokeWidth={12} strokeLinecap="round" fill="none" />
<path d="M-20 -60 Q-14 -120 -18 -180 M-4 -240 Q2 -280 -2 -320" stroke={p.lo(bark, 0.3)} strokeWidth={5} strokeLinecap="round" fill="none" />
<Foliage blobs={blobs} color={leaf} p={p} />
</g>;
},
pine: (p, color) => {
const leaf = color ?? mix(p.pal.leaf, "#1f5a46", 0.35);
const tiers: [number, number, number][] = [[-200, -90, -440], [-165, -300, -640], [-125, -500, -840]];
return <g>
<rect x={-22} y={-110} width={44} height={110} fill={p.c(p.pal.trunk)} />
<rect x={4} y={-110} width={18} height={110} fill={p.lo(p.pal.trunk, 0.4)} />
{tiers.map(([w, b, t], i) => <g key={i}>
<polygon points={`0,${t} ${w},${b} ${-w},${b}`} fill={p.c(leaf)} />
<polygon points={`0,${t} ${-w},${b} ${-w * 0.1},${b}`} fill={p.lo(leaf, 0.42)} />
<polygon points={`0,${t} ${w * 0.55},${b - (b - t) * 0.42} ${w * 0.25},${b - (b - t) * 0.4}`} fill={p.hi(leaf, 0.2)} />
<path d={`M${w} ${b} L${-w} ${b} L${-w * 0.92} ${b - 18} L${w * 0.92} ${b - 18} Z`} fill={p.lo(leaf, 0.55)} />
</g>)}
</g>;
},
deadtree: (p, color) => {
const bark = color ?? p.pal.trunk;
return <g strokeLinecap="round" fill="none">
<g stroke={p.c(bark)}>
<path d="M0 0 L0 -440" strokeWidth={52} />
<path d="M0 -240 L-140 -400 M-80 -320 L-160 -300 M0 -340 L120 -500 M60 -420 L160 -430 M0 -440 L-40 -560" strokeWidth={24} />
</g>
<g stroke={p.lo(bark, 0.45)}>
<path d="M14 0 L14 -430" strokeWidth={18} />
<path d="M8 -346 L124 -496" strokeWidth={9} />
</g>
<path d="M-30 0 Q-60 4 -80 0 M30 0 Q60 4 84 0" stroke={p.c(bark)} strokeWidth={20} />
</g>;
},
bush: (p, color) => <Foliage blobs={jitter(p, [[-90, -70, 85], [15, -105, 105], [115, -66, 80], [-165, -42, 56], [180, -38, 52], [40, -50, 70]], 0.6)} color={color ?? p.pal.leaf} p={p} />,
rock: (p, color) => {
const s = color ?? p.pal.stone;
return <g>
<path d="M-120 0 Q-138 -84 -52 -118 Q34 -150 104 -84 Q146 -34 120 0 Z" fill={p.c(s)} />
<path d="M30 -134 Q96 -116 114 -66 Q140 -30 120 0 L6 0 Q44 -64 30 -134 Z" fill={p.lo(s, 0.38)} />
<path d="M-106 -40 Q-110 -98 -44 -116 Q-16 -124 6 -122 Q-44 -100 -66 -40 Z" fill={p.hi(s, 0.25)} />
</g>;
},
mountain: (p, color) => {
const m = color ?? p.pal.far;
return <g>
<polygon points="-520,0 -60,-470 0,-520 70,-460 520,0" fill={p.c(m)} />
<polygon points="0,-520 70,-460 520,0 80,0 150,-140 40,-260 60,-380" fill={p.lo(m, 0.3)} />
<polygon points="-60,-470 0,-520 -40,-400 -140,-250 -260,-150 -150,-300" fill={p.hi(m, 0.12)} />
<polygon points="-110,-410 -60,-470 0,-520 70,-460 110,-410 50,-432 10,-396 -40,-436" fill={p.c("#ffffff")} opacity={0.85} />
<polygon points="0,-520 70,-460 110,-410 50,-432 22,-410" fill={p.lo("#e8ecf4", 0.3)} opacity={0.85} />
</g>;
},
cloud: (p, color) => {
const base = color ?? mix("#ffffff", p.pal.light, 0.12);
return <g opacity={0.95}>
<Foliage blobs={[[-80, -50, 52], [0, -78, 66], [78, -52, 50], [-140, -34, 34], [140, -32, 32]]} color={base} p={p} shadeK={0.2} hiK={0} lift={0.22} />
<rect x={-174} y={-34} width={348} height={34} rx={17} fill={p.lo(base, 0.22)} />
</g>;
},
palm: (p, color) => {
const leaf = color ?? p.pal.leaf;
const bark = mix(p.pal.trunk, "#b08a5a", 0.35);
const fronds: [number, number][] = [[-250, -470], [-210, -600], [-40, -700], [150, -650], [270, -500], [60, -560]];
return <g>
<path d="M-22 0 Q-40 -260 20 -560 L52 -556 Q2 -260 26 0 Z" fill={p.c(bark)} />
<path d="M8 0 Q-6 -260 40 -558 L52 -556 Q2 -260 26 0 Z" fill={p.lo(bark, 0.4)} />
{Array.from({ length: 9 }, (_, i) => {
const y = -40 - i * 58;
const x = -14 + (i / 9) * 40 - Math.sin((i / 9) * 2) * 10;
return <path key={i} d={`M${x - 20} ${y} Q${x + 4} ${y + 10} ${x + 30} ${y}`} stroke={p.lo(bark, 0.5)} strokeWidth={6} fill="none" strokeLinecap="round" />;
})}
{fronds.map(([x, y], i) => {
const ox = 36;
const oy = -560;
const mx = (ox + x) / 2;
const my = Math.min(oy, y) - 70;
return <g key={i}>
<path d={`M${ox} ${oy} Q${mx} ${my - 34} ${x} ${y} Q${mx} ${my + 44} ${ox} ${oy} Z`} fill={p.c(leaf)} />
<path d={`M${ox} ${oy} Q${mx} ${my + 6} ${x} ${y} Q${mx} ${my + 44} ${ox} ${oy} Z`} fill={p.lo(leaf, 0.42)} />
</g>;
})}
<circle cx={24} cy={-540} r={20} fill={p.c("#6a4a2a")} /><circle cx={52} cy={-532} r={18} fill={p.lo("#6a4a2a", 0.3)} />
</g>;
},
outcrop: (p, color) => {
const s = color ?? mix(p.pal.stone, p.pal.ground.dirt, 0.5);
return <g>
<path d="M-330 0 Q-300 -70 -160 -96 Q0 -116 170 -94 Q310 -70 330 0 Z" fill={p.c(s)} />
<path d="M60 -110 Q200 -96 290 -60 Q320 -36 330 0 L40 0 Q110 -50 60 -110 Z" fill={p.lo(s, 0.32)} />
{[-30, -56, -78].map((y, i) => <path key={y} d={`M${-300 + i * 40} ${y} Q0 ${y - 22} ${300 - i * 40} ${y}`} stroke={p.lo(s, 0.5)} strokeWidth={5} fill="none" />)}
<path d="M-330 0 Q-300 -70 -160 -96 L-150 -80 Q-280 -50 -300 0 Z" fill={p.hi(s, 0.3)} />
</g>;
},
rainbow: () => {
const bands = ["#e8463d", "#f28c28", "#f2c230", "#5cc48a", "#4fb0e8", "#7a5ce0"];
return <g fill="none" opacity={0.78}>{bands.map((c, i) => <path key={c} d={`M${-600 + i * 26} 0 A${600 - i * 26} ${600 - i * 26} 0 0 1 ${600 - i * 26} 0`} stroke={c} strokeWidth={27} />)}</g>;
},
waves: (p, color) => {
const water = color ?? p.pal.ground.water;
const d = Array.from({ length: 7 }, (_, i) => `Q${-300 + i * 100 + 50} -70 ${-300 + (i + 1) * 100} 0`).join(" ");
return <g>
<path d={`M-300 0 ${d} L400 40 L-300 40 Z`} fill={p.lo(water, 0.3)} />
<path d={`M-300 6 ${d} L400 12 L-300 12 Z`} fill={p.c(water)} opacity={0.7} />
<path d={`M-300 0 ${d}`} stroke={p.hi("#ffffff", 0)} strokeWidth={9} fill="none" opacity={0.75} strokeLinecap="round" />
</g>;
},
};
+88
View File
@@ -0,0 +1,88 @@
// Tinta do cenário: paletas, mistura de cor e o "pincel" de cada peça. Toda peça pinta em 2 tons (cel): a cor
// base e o lado da sombra, num tom mais escuro e frio da própria cor (nunca contorno preto). A luz vem da
// ESQUERDA em todas as peças. A distância (z) puxa a cor para a do céu/parede (perspectiva atmosférica) e a
// frente fica um pouco mais escura e contrastada — tudo por mistura de cor, sem filtro (render barato).
export const PALETTES = ["night", "sepia", "day", "dusk", "gray"] as const;
export type PaletteId = (typeof PALETTES)[number];
export type Pal = {
/** Céu: topo, meio e perto do horizonte. */
sky: [string, string, string];
wall: string;
ground: Record<string, string>;
far: string; near: string; ink: string; leaf: string; trunk: string; stone: string;
/** Cor da luz (lado iluminado, lâmpada, sol). */
light: string;
/** Cor fria para onde as sombras puxam. */
shade: string;
/** Sol/lua: cor do disco e do halo. */
sun: string; halo: string;
/** Contraluz: quanto toda peça escurece para o frio (entardecer = sol baixo atrás das coisas). */
dim?: number;
};
const P: Record<PaletteId, Pal> = {
night: { sky: ["#070a1c", "#141a3e", "#2a3264"], wall: "#25304f", far: "#2c3463", near: "#3d4a7c", ink: "#0c0d1a", leaf: "#2a4a5a", trunk: "#3a2e40",
stone: "#5a6088", light: "#ffc965", shade: "#05081c", sun: "#f4ecc8", halo: "#8a9ad8",
ground: { grass: "#22384a", street: "#232842", dirt: "#33304a", floor: "#2a2e48", sand: "#4a4868", water: "#16305a" } },
sepia: { sky: ["#b8956a", "#dcc196", "#f0dfb8"], wall: "#6e6248", far: "#b49a74", near: "#7a5e46", ink: "#2a2018", leaf: "#7f8048", trunk: "#5a4330",
stone: "#a39a8a", light: "#ffdc8e", shade: "#2c2a3a", sun: "#fff0c0", halo: "#ffd890",
ground: { grass: "#8f8c54", street: "#76685a", dirt: "#8a6a48", floor: "#7a5e44", sand: "#d8bd8a", water: "#6f8a8a" } },
day: { sky: ["#3f8fd8", "#7fbdec", "#d4ecf8"], wall: "#e6d6b6", far: "#a6c8de", near: "#e09a68", ink: "#22252e", leaf: "#5aa84a", trunk: "#7a5232",
stone: "#a9adb5", light: "#fff2be", shade: "#2a3a78", sun: "#fff8d8", halo: "#fff2b0",
ground: { grass: "#7cc25e", street: "#8a8f99", dirt: "#c49060", floor: "#c69c6c", sand: "#f0d79a", water: "#3f9ad8" } },
dusk: { sky: ["#5c5a9a", "#e49a72", "#f8d08a"], wall: "#5a4658", far: "#b48a98", near: "#c98a6a", ink: "#20141c", leaf: "#6a8540", trunk: "#5e3a2a",
stone: "#9a8a92", light: "#ffcf86", shade: "#3a2a62", sun: "#ffe7a8", halo: "#ffc070", dim: 0.12,
ground: { grass: "#6e8448", street: "#6a5a64", dirt: "#c27a4c", floor: "#6e5048", sand: "#dba878", water: "#5a6aa0" } },
gray: { sky: ["#5f6670", "#8d949c", "#c0c4c8"], wall: "#565b63", far: "#8f969e", near: "#646a72", ink: "#1b1d21", leaf: "#5a6b55", trunk: "#4a4038",
stone: "#9aa0a8", light: "#f2e6c8", shade: "#1e2430", sun: "#e8e8e0", halo: "#c8ccd0",
ground: { grass: "#5f6e55", street: "#4a4f57", dirt: "#5e5246", floor: "#4a4d54", sand: "#a8a08a", water: "#5a6f80" } },
};
export const palette = (id: PaletteId | undefined): Pal => P[id ?? "night"] ?? P.night;
/** Mistura duas cores hex (#rrggbb) em k (0 = a, 1 = b). */
export function mix(a: string, b: string, k: number): string {
const pa = parseInt(a.slice(1, 7), 16);
const pb = parseInt(b.slice(1, 7), 16);
const q = Math.max(0, Math.min(1, k));
const ch = (s: number) => Math.round(((pa >> s) & 255) * (1 - q) + ((pb >> s) & 255) * q);
return `#${[16, 8, 0].map((s) => ch(s).toString(16).padStart(2, "0")).join("")}`;
}
/** Pincel de uma peça: já sabe a profundidade, a paleta e o sorteio da semente. */
export type Paint = {
pal: Pal;
r: () => number;
indoor: boolean;
night: boolean;
/** Cor base (com a névoa da distância). */
c: (hex: string) => string;
/** Lado da sombra: mais escuro e frio (k = quanto). */
lo: (hex: string, k?: number) => string;
/** Lado da luz: mais claro e quente. */
hi: (hex: string, k?: number) => string;
};
/**
* `haze` = quanto a peça puxa para a cor do fundo (0–1); `front` = quanto escurece por estar na frente (0–0,2).
* Os resultados ficam em cache por peça: o mesmo hex sai sempre igual.
*/
export function makePaint(pal: Pal, r: () => number, opts: { haze: number; hazeColor: string; front: number; indoor: boolean; night: boolean }): Paint {
const cache = new Map<string, string>();
const base = (hex: string) => {
const hit = cache.get(hex);
if (hit) return hit;
let v = pal.dim ? mix(hex, pal.shade, pal.dim) : hex;
if (opts.front > 0) v = mix(v, pal.ink, opts.front);
if (opts.haze > 0) v = mix(v, opts.hazeColor, opts.haze);
cache.set(hex, v);
return v;
};
return {
pal, r, indoor: opts.indoor, night: opts.night,
c: base,
lo: (hex, k = 0.3) => base(mix(hex, pal.shade, k)),
hi: (hex, k = 0.2) => base(mix(hex, pal.light, k)),
};
}
+303
View File
@@ -0,0 +1,303 @@
// Biblioteca de MÃOS desenhadas (não montadas com cápsulas): cada forma é um desenho num quadro fixo de 120×120,
// com a silhueta inteira num path só (Bézier contínuas: dedos afinando em 3 falanges, nós em arco, polegar nascendo
// do montinho da base da palma), as linhas internas no tom escuro da pele, unhas, e uma sombra cel DESENHADA
// (recortada pela silhueta). O rig só ESCOLHE a forma, posiciona no pulso, gira e espelha.
//
// Regras de construção seguidas (ensino de desenho de mão): palma ≈ quadrada com laterais curvas; dedo médio ≈ altura
// da palma, médio o maior, indicador ≈ anelar, mínimo o menor; nós da base e pontas em ARCO (o médio mais à frente);
// dedo afina para a ponta; polegar com 2 segmentos e unha, girando em outro eixo; pulso mais estreito que a palma;
// volume com sombra no lado oposto à luz e embaixo dos dedos; linhas internas sempre curvas.
//
// Quadro canônico: braço da DIREITA da tela (s = 1), luz vinda da esquerda (sombra desenhada à direita/embaixo).
// - formas "alinhadas" (relaxed, open, point, fist, on_face): o antebraço chega por cima (pulso em (60, 4)) e os dedos
// apontam para +y; o polegar fica do lado −x. O rig gira pelo ângulo do antebraço.
// - formas "em pé" (thumbs_up, grip, pinch_edge): desenhadas na orientação da tela, com o pulso num canto e o ângulo
// do antebraço para o qual foram feitas (`wristDeg`); o rig só inclina um pouco para acompanhar o braço.
import React from "react";
import type { IconId } from "./spec";
export const HAND_SHAPES = ["relaxed", "open", "point", "thumbs_up", "grip", "pinch_edge", "pinch_low", "fist", "on_face"] as const;
export type HandShape = (typeof HAND_SHAPES)[number];
type ShapeDef = {
/** Silhueta inteira (um path). */
body: string;
/** Sombra cel desenhada (recortada pela silhueta do corpo). */
shadow: string;
/** Linhas internas do corpo: separação dos dedos, nós, dobras. */
lines: string;
/** Peça por cima (polegar dobrado por cima dos dedos ou do objeto), com sombra e linhas próprias. */
over?: { body: string; shadow?: string; lines?: string };
/** Unhas: [cx, cy, rx, ry, giro]. A primeira do corpo, as de `overNails` por cima. */
nails?: [number, number, number, number, number][];
overNails?: [number, number, number, number, number][];
/** Pulso no quadro (onde encosta o fim do antebraço). */
wrist: [number, number];
/** Ângulo do antebraço para o qual a forma foi desenhada (0 = descendo; formas alinhadas = 0). */
wristDeg: number;
upright: boolean;
/** Com objeto: o corpo fica ATRÁS do objeto (só a peça `over` na frente) — pinch_edge. */
bodyBehind?: boolean;
/** Onde fica o objeto: cabo (grip) ou borda (pinch_edge). */
hold?: [number, number];
};
// Pulso: cilindro com ≈ 60 % da largura da palma (27 unidades), centrado no ponto `wrist`, com uma sobra de 10
// unidades que entra por baixo da manga (fica escondida pelo punho da manga). Sombra do lado oposto à luz (direita):
// no pulso ela tem a mesma largura da sombra do antebraço (≈ 1/3) e vai afinando na borda da mão; sob os dedos dobrados
// e sob o polegar.
const WRIST_TOP = "M46.5 -10 L46.5 3";
const WRIST_RIGHT_END = "C74.4 6.5 73.6 3 73.5 0 L73.5 -10 Z";
const SHAPES: Record<HandShape, ShapeDef> = {
// Caída ao lado do corpo, vista pelo dorso: dedos juntos levemente curvos (nós e pontas em arco), polegar na frente.
relaxed: {
body: `${WRIST_TOP} C45.5 12 41 18 38.5 25 C35.5 33 34 42 35 50 C35.8 57 38.5 61 42 60.5 C45 60 46 57 45.6 53 C45.3 49 45 46 44.8 44`
+ " C43.6 52 42.8 62 43 72 C43.2 79 45.2 82.5 48.3 82.5 C51.3 82.5 52.6 80 52.6 76.5 L52.8 74 C53 80 53.4 86 55.2 89"
+ " C56.6 91.6 60 92 61.8 89.8 C63 88 63.2 85 63.2 81 L63.4 78 C63.8 82 64.6 85.5 66.4 87.2 C68.4 89 71.4 88.2 72.2 85.4"
+ " C72.8 83 72.8 80 72.6 77 L72.8 74 C73.8 76.5 75.4 78 77.4 77.6 C79.6 77 80.6 74.6 80.7 71.5 C81 64 81.8 54 82 46"
+ ` C82.2 34 79.5 20 75.5 10 ${WRIST_RIGHT_END}`,
shadow: "M64.6 -12 L65 1 C69 6 75 12 78 22 C79.6 32 80 42 79.6 52 C79.2 62 78.6 70 78.8 76 L96 80 L96 -12 Z"
+ " M40 77 C48 84.5 62 90.5 80 76 L80 100 L40 100 Z M45.2 45 C46.6 52 47 59 46.6 65 L49.6 66 C49.8 58 49.2 50 47.6 44 Z",
lines: "M52.8 74 C52.7 68 52.8 62 53.2 56 M63.4 78 C63.4 71 63.2 64 63 57 M72.8 74 C73 68 73.4 62 73.8 55 M44.8 44 C44.5 38 43 32 41 27",
nails: [[40.6, 54.2, 2.8, 3.8, 6]],
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Aberta, palma para a câmera (acenando): dedos levemente abertos, polegar saindo da eminência tenar.
open: {
body: `${WRIST_TOP} C44 12 39 18 35 22 C29 26 24 31 21 37 C18.5 42 19.5 47 23.5 47.5 C26.5 48 28.5 45.5 30 42.5 C32.5 38 35.5 35 38.5 34.5`
+ " C39 38 39.2 41 39.5 44 C38.6 54 38 64 38.4 72 C38.6 78 41 80.6 44 80.4 C47 80.2 48.4 78 48.4 74.6 C48.6 64 48.8 55 49.4 47.5"
+ " C50.4 58 50.8 70 51.2 80 C51.4 86 54.2 88.6 57.2 88.4 C60.2 88.2 61.6 85.6 61.4 82 C61 70 60.8 58 61.2 48"
+ " C62.6 58 63.6 68 64.4 76 C64.8 81.4 67.6 83.6 70.4 83 C73 82.4 74 79.8 73.6 76.6 C72.6 66 72 56 72 47.4"
+ " C73.8 54 75.6 61 77.6 66.6 C79 70.6 82 71.6 84.2 70 C86 68.6 86 66 85.2 63 C83 54 82.6 42 81.6 30 C80.6 18 76 8 73.5 2 L73.5 -10 Z",
shadow: "M64.6 -12 L65 1 C70 6 77 14 80.6 32 C81.6 44 82 54 83.4 64 L96 64 L96 -12 Z M50 30 C56 36 66 38.4 75 34 C70 42 60 44.4 51 40 Z"
+ " M45.6 50 C46.2 60 46.4 70 46 80.4 L49 80 L49.2 50 Z M58.4 50 C58.8 62 59.2 74 59 88.4 L62 88 L61.6 50 Z M70.4 50 C71.2 60 71.8 70 72 82 L74.6 81 L73.6 50 Z",
lines: "M48 46 C58 42.4 70 42.4 80 46 M42 40 C46 32 50 22 52 12",
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Apontando, vista pelo lado da palma: indicador esticado (3 falanges, afinando, unha na ponta, leve curva); médio,
// anelar e mínimo dobrados como gomos empilhados em arco (médio mais à frente), com a ponta virada para a palma e a
// UNHA de cada um aparecendo; o polegar fecha por cima do médio, com a unha dele.
point: {
body: `${WRIST_TOP} C45 12 40 18 37.5 26 C36 34 36.2 42 38.2 48 C37.8 60 37.9 72 38.5 82 C39 90 39.6 96 40.6 101.4`
+ " C41.4 106.6 46 108.4 49.2 106 C51.6 104.2 52.2 100.4 52.2 96.6 C52.2 88 52.6 76 53.4 64"
+ " C54 68.6 56.8 71 60.6 70.6 C64 70.2 65.6 67.6 65.8 64.8 C68 68 71.6 68.4 74 66.6 C76 65 76.4 62 76 59.8"
+ ` C78.4 60.6 81 59.4 81.8 56.4 C82.6 53 82.4 49 82 46 C82 34 79.5 20 75.5 10 ${WRIST_RIGHT_END}`,
shadow: "M64.6 -12 L65 1 C70 6 78 14 80.8 30 C81.6 40 81 48 79.6 52 C76 50 70 49 64 50 L96 50 L96 -12 Z"
+ " M50 66 C56 72.6 68 72 74 68 C78 66 81 62 83 56 L86 80 L48 80 Z M49.6 66 C50.2 78 50.6 92 50.2 108 L58 108 L58 66 Z"
+ " M44 58 C48 62 52 64.4 56.4 63.6 L58 67 L44 64 Z",
lines: "M65.8 64.8 C65.4 60.6 64.4 57.6 62.8 55.4 M76 59.8 C75.4 56 74.2 53.4 72.6 51.6 M53 57.4 C60 53.6 70 51.4 81 47"
+ " M38.8 81 Q45.4 82.6 52.4 81 M40.2 93 Q46 94.4 52.2 93",
nails: [[59.6, 66.6, 3.2, 2.4, 6], [70.8, 63.4, 2.9, 2.2, -8], [79.2, 54.6, 2.3, 1.9, -30], [45.8, 102, 3, 3.6, -4]],
over: {
body: "M38.4 30 C42 38 47 46 52.8 52 C56.2 55.4 57 60 54 61.6 C51 63.2 47.4 60.4 44.4 56.6 C40.8 52 38 46 37.6 40 Z",
shadow: "M39.6 46 C42 51 46 56 50 59 L46 62 L38 52 Z",
},
overNails: [[53.2, 57.2, 3, 2.6, 40]],
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Joinha: punho de lado, os 4 dedos dobrados na horizontal (um em cima do outro, nós e pontas na frente),
// polegar grosso saindo do topo, com unha, levemente inclinado para trás. Antebraço chegando de baixo, na diagonal.
thumbs_up: {
body: "M56 42 C46 39.5 34 40 29 44.5 C24.6 48.6 25.2 54.4 29.6 56 C25.2 58.6 24.8 65.4 29.4 67.8 C25.8 70.6 26.4 77.6 31 79.4"
+ " C28.6 82.6 30.6 88.4 36 89.4 C46 91.2 60 92.6 72 93.6 C78 94.4 83 97.2 86.5 101.5 L93.6 108.6 L112.6 89.6 L105.5 82.5"
+ " C101 77.6 96 70.4 92 61 C89.4 54.4 85 48 78 45 C77.6 40 76.8 30 75.4 20 C74.4 13 71.6 7 66 6.4"
+ " C60.6 5.8 57.4 9.6 56.8 15.6 C56.2 24 55.8 33 56 42 Z",
shadow: "M84 46 C90 52 95 62 98 72 L104 82 L120 96 L120 40 Z M28 54.6 C38 57.8 50 58 60 56.6 L60 59.6 C48 61 38 60.6 28 58 Z"
+ " M28 66.4 C38 69.6 50 70 60 68.6 L60 71.6 C48 73 38 72.6 28 70 Z M30 78 C40 81 50 81.6 58 80.6 L58 83.6 C48 84.6 40 84 30 81.4 Z"
+ " M30 88 C46 92 62 94 74 95 L86 104 L40 104 Z M71 8 C74 14 76 24 77 40 L84 44 L84 4 Z",
lines: "M29.6 56 C38 58 48 58.4 58 57 M29.4 67.8 C38 70 48 70.4 58 69 M31 79.4 C39 81.4 48 81.8 56 81"
+ " M58 57 C62 55.6 64.6 52.6 65.4 49 M58 69 C62.6 67.6 65.6 64.6 66.4 60.6 M56 81 C60.4 80 63.4 77.4 64.4 73.6 M57 34.5 C62 37 70 37.4 77 33.6",
nails: [[65.4, 13.8, 5, 6, 4]],
wrist: [96, 92], wristDeg: 135, upright: true,
},
// Punho em volta de um cabo (martelo, régua, ramo, celular): o cabo passa por dentro, o polegar fecha por cima.
grip: {
body: "M44 42 C34 41.6 26.6 43.6 26.2 49 C25.8 53.4 26.8 55.6 29.6 56 C25.2 58.6 24.8 65.4 29.4 67.8 C25.8 70.6 26.4 77.6 31 79.4"
+ " C28.6 82.6 30.6 88.4 36 89.4 C48 91.4 64 92 76 89.6 C86 87.4 92.6 80 94.4 70 C96 62 100 55 105.5 49.5 L112.6 42.4 L93.6 23.4 L86.5 30.5"
+ " C80 36 72 39.6 62 41 C56 41.8 50 42 44 42 Z",
shadow: "M86 34 C92 44 95 58 94 70 C92 82 84 90 74 92 L120 120 L120 30 Z M28 54.6 C38 57.8 50 58 60 56.6 L60 59.6 C48 61 38 60.6 28 58 Z"
+ " M28 66.4 C38 69.6 50 70 60 68.6 L60 71.6 C48 73 38 72.6 28 70 Z M30 78 C40 81 50 81.6 58 80.6 L58 83.6 C48 84.6 40 84 30 81.4 Z"
+ " M30 88 C46 92 62 93 78 90 L78 100 L30 100 Z",
lines: "M29.6 56 C38 58 48 58.4 58 57 M29.4 67.8 C38 70 48 70.4 58 69 M31 79.4 C39 81.4 48 81.8 56 81"
+ " M58 57 C62 55.6 64.6 52.6 65.4 49 M58 69 C62.6 67.6 65.6 64.6 66.4 60.6 M56 81 C60.4 80 63.4 77.4 64.4 73.6",
over: {
body: "M80 36 C72 30.6 58 29.6 46 32.6 C37 34.8 33.4 40.6 36.6 44.2 C40.6 47.6 52 46.6 62 45.6 C70 44.8 76 43 79 40.6 Z",
shadow: "M36 43 C44 46.6 58 46.4 72 44 L72 48 L36 48 Z",
},
overNails: [[40.6, 39.4, 4.2, 3.6, -12]],
wrist: [96, 40], wristDeg: 45, upright: true, hold: [44, 66],
},
// Segurando a borda de um objeto largo (em par): dedos atrás do objeto, polegar grosso por cima da frente dele.
// Antebraço chegando de cima, por fora (pose hold_both).
pinch_edge: {
body: "M56 32 C62 27 72 26.6 80 30.6 C83.6 32.6 85.6 37 87 42 L94.4 35.3 L112.4 55.3 L105 62 C102 70.4 97 78 90 83.4"
+ " C82.6 89 72.6 92 64 90.6 C58.6 89.6 55.6 86 55 80 C54 64 54 46 56 32 Z",
shadow: "M82 30 C90 38 94 50 94 62 C92 74 86 82 76 88 L120 120 L120 20 Z M55 78 C60 86 70 90 84 88 L84 96 L54 96 Z",
lines: "M56 46 C62 46 68.6 47.6 74 50.6 M55.6 60 C61.4 60.4 67.6 62 73 64.8 M55.6 73.6 C60.6 74 65.4 75.6 69.6 78",
over: {
body: "M70 46 C62 40 52 34.6 45 31.6 C38.4 28.8 33 32.4 35 38.4 C37.4 45 46.4 51 55.6 57 C62 61 70.4 57.6 70 46 Z",
shadow: "M36.4 40.6 C43 47 52 53 60 58 L68 58 L68 64 L34 46 Z",
},
overNails: [[39.8, 35.2, 4.2, 3.6, 30]],
wrist: [96, 52], wristDeg: 48, upright: true, bodyBehind: true, hold: [56, 52],
},
// A mesma pegada de borda com o antebraço chegando de baixo (close de mãos segurando um livro aberto).
pinch_low: {
body: "M56 30 C64 25 78 26 85 34 C90 41 93 52 95 62 C96.6 70 100 78 105.5 86.5 L112.6 93.6 L93.6 112.6 L86.5 105.5"
+ " C80 98 72 94.6 66 92.4 C59 90 56 85.6 55 79 C53.6 64 53.6 44 56 30 Z",
shadow: "M80 28 C90 40 94 56 96 68 C98 78 102 84 110 92 L120 120 L120 20 Z M55 78 C60 86 68 91 80 96 L80 104 L54 100 Z",
lines: "M56 46 C62 46 68.6 47.6 74 50.6 M55.6 60 C61.4 60.4 67.6 62 73 64.8 M55.6 73.6 C60.6 74 65.4 75.6 69.6 78",
over: {
body: "M70 46 C62 40 52 34.6 45 31.6 C38.4 28.8 33 32.4 35 38.4 C37.4 45 46.4 51 55.6 57 C62 61 70.4 57.6 70 46 Z",
shadow: "M36.4 40.6 C43 47 52 53 60 58 L68 58 L68 64 L34 46 Z",
},
overNails: [[39.8, 35.2, 4.2, 3.6, 30]],
wrist: [96, 96], wristDeg: 135, upright: true, bodyBehind: true, hold: [56, 52],
},
// Fechada, vista pelo lado da palma: os 4 dedos dobrados como gomos em arco (médio mais à frente, mínimo menor),
// com a ponta virada para a palma e a UNHA de cada um; o polegar fecha por cima do indicador e do médio.
fist: {
body: `${WRIST_TOP} C45 12 40 18 37.5 26 C36 34 36.2 42 38 50 C39.4 57 42.4 62 46.6 63.6 C50 65 53.2 64 54.4 61.4`
+ " C56 66.4 60 69 64 68.4 C67.4 67.8 69 65.2 69.2 62.4 C71.4 65.8 75 66.2 77.4 64.2 C79.4 62.4 79.8 59.4 79.4 57"
+ ` C81.6 57 82.6 53 82.4 48 C82.2 34 79.5 20 75.5 10 ${WRIST_RIGHT_END}`,
shadow: "M64.6 -12 L65 1 C70 6 78 14 80.8 30 C81.6 40 81 46 80 50 L96 50 L96 -12 Z M40 58 C48 68 66 72 82 54 L84 80 L38 80 Z",
lines: "M54.4 61.4 C53.8 57 52.4 54 50.6 52 M69.2 62.4 C68.8 58.4 67.6 55.6 66 53.6 M79.4 57 C78.6 53.6 77.4 51.2 75.8 49.6 M44 51 C54 47.6 68 45.6 81 43.6",
nails: [[46, 59.6, 3, 2.3, 10], [62.6, 64.4, 3.2, 2.4, 0], [74.2, 61.2, 2.8, 2.1, -10], [80, 53, 2.2, 1.8, -30]],
over: {
body: "M38 30 C42 39 48 47 55 52 C59 54.6 60.4 59 57 60.6 C53 62.4 47.6 59 43.6 54.6 C39.8 50.4 37.4 42 38 30 Z",
shadow: "M39.4 46 C42.6 52 47 57 52 60 L48 63 L38 52 Z",
},
overNails: [[56.6, 56.8, 3.1, 2.7, 35]],
wrist: [60, 0], wristDeg: 0, upright: false,
},
// Apoiada no rosto (queixo, boca, lateral da cabeça): dorso, dedos juntos e mais retos, polegar recolhido.
on_face: {
body: `${WRIST_TOP} C45.5 12 41.5 18 39.5 25 C37.5 32 37.5 40 39 46 C39.5 58 39.6 70 40.4 82 C40.8 88 43.4 91.4 46.4 91.2`
+ " C49.4 91 50.6 88.4 50.8 85 L51 83 C51.4 90 53.6 94.4 57 94.4 C60.4 94.4 62 91.4 62.2 87.6 L62.3 85.6 C63 91 65.4 93.4 68.4 93"
+ " C71.4 92.6 72.4 89.8 72.4 86.4 L72.5 83.6 C73.6 87 75.6 88.2 77.6 87.6 C79.8 86.8 80.6 84 80.8 80.6 C81.6 70 82.2 56 82 44"
+ ` C81.8 32 79.2 20 75.5 10 ${WRIST_RIGHT_END}`,
shadow: "M64.6 -12 L65 1 C70 6 78 14 80.4 36 C81 50 80.6 66 79.6 84 L96 84 L96 -12 Z M40 84 C48 92 66 97 82 84 L82 104 L40 104 Z",
lines: "M51 83 C51 74 51.2 66 51.6 58 M62.3 85.6 C62.3 76 62.2 67 62 58 M72.5 83.6 C72.8 75 73 66 73.2 57",
over: {
body: "M39.5 25 C35 31 33.6 40 35.4 46 C36.8 50.4 41 50 41.6 46 C42.2 41 42 34 41.8 28 Z",
},
overNails: [[37.4, 44.6, 2.4, 3.2, 6]],
wrist: [60, 0], wristDeg: 0, upright: false,
},
};
/** Objetos seguros com as DUAS mãos (pelas bordas, na frente do peito). O resto vai numa mão só (`grip`). */
export const TWO_HANDED: IconId[] = ["book", "tablet"];
/**
* Como cada objeto entra no punho (`grip`): ponto do cabo no quadro 100×100 do ícone e o giro que deixa o cabo em pé
* (cabeça do martelo, ponta do ramo e da régua para cima). Sem entrada: pelo meio, sem girar.
*/
export const GRIP: Partial<Record<IconId, { x: number; y: number; rot: number }>> = {
hammer: { x: 50, y: 80, rot: 20 },
olive: { x: 26, y: 80, rot: -43 },
ruler: { x: 14, y: 58, rot: -78 },
phone: { x: 50, y: 74, rot: 0 },
fuel: { x: 50, y: 30, rot: 0 },
bulb: { x: 50, y: 82, rot: 0 },
};
/**
* Posição da forma: espelho (`mirror`), giro em graus e escala, a partir do pulso na tela, do ângulo do antebraço e do
* lado do braço. Formas alinhadas giram com o antebraço; as "em pé" só inclinam até ±30° para acompanhá-lo.
*/
export function handPlacement(shape: HandShape, x: number, y: number, foreDeg: number, s: number, k: number) {
const def = SHAPES[shape];
let mirror: number;
let rot: number;
if (def.upright) {
// Desenhada para o braço da direita; o pulso acompanha o eixo do antebraço (gira em torno do centro do pulso).
mirror = s >= 0 ? 1 : -1;
rot = foreDeg - def.wristDeg * mirror;
} else {
// Polegar do lado do corpo; com o braço erguido o eixo local vira e o espelho inverte junto.
const up = Math.cos((foreDeg * Math.PI) / 180) >= 0;
mirror = up ? s : -s;
rot = foreDeg;
}
const [wx, wy] = def.wrist;
const transform = `translate(${x} ${y}) rotate(${rot}) scale(${k * mirror} ${k}) translate(${-wx} ${-wy})`;
const r = (rot * Math.PI) / 180;
/** Ponto do quadro 120×120 → tela. */
const map = (px: number, py: number) => {
const lx = (px - wx) * k * mirror;
const ly = (py - wy) * k;
return { x: x + lx * Math.cos(r) - ly * Math.sin(r), y: y + lx * Math.sin(r) + ly * Math.cos(r) };
};
return { def, mirror, rot, transform, map, hold: def.hold ? map(def.hold[0], def.hold[1]) : null };
}
/** Pulso que põe o ponto `hold` da forma em (hx, hy) — para pôr as mãos nas bordas do objeto. */
export function wristForHold(shape: HandShape, hx: number, hy: number, foreDeg: number, s: number, k: number) {
const p = handPlacement(shape, 0, 0, foreDeg, s, k);
return { x: hx - (p.hold?.x ?? 0), y: hy - (p.hold?.y ?? 0) };
}
function shadeHex(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16);
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v * k))).toString(16).padStart(2, "0");
return `#${c((n >> 16) & 255)}${c((n >> 8) & 255)}${c(n & 255)}`;
}
/** Mistura duas cores hex (0 = a, 1 = b). */
function mixHex(a: string, b: string, t: number): string {
const pa = parseInt(a.slice(1), 16), pb = parseInt(b.slice(1), 16);
const ch = (sh: number) => Math.round(((pa >> sh) & 255) * (1 - t) + ((pb >> sh) & 255) * t).toString(16).padStart(2, "0");
return `#${ch(16)}${ch(8)}${ch(0)}`;
}
function coolHex(hex: string, k: number): string {
const n = parseInt(hex.slice(1), 16);
const r = ((n >> 16) & 255) * k * 0.94, g = ((n >> 8) & 255) * k * 0.97, b = (n & 255) * k + 10;
const c = (v: number) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
return `#${c(r)}${c(g)}${c(b)}`;
}
/**
* Desenha a forma de mão no lugar. `layer`: "back" = o que fica atrás do objeto, "front" = o que fica na frente,
* "all" = tudo. `light` = lado da sombra na tela (1 = direita). Sem contorno: a borda é o tom escuro da pele.
*/
export function HandArt({ shape, x, y, foreDeg, s, k, skin, light = 1, layer = "all", uid }: {
shape: HandShape; x: number; y: number; foreDeg: number; s: number; k: number; skin: string; light?: number;
layer?: "all" | "back" | "front"; uid: string;
}) {
const p = handPlacement(shape, x, y, foreDeg, s, k);
const def = p.def;
// A sombra foi desenhada à direita; se, depois de espelhar e girar, a direita do desenho não cai do lado da sombra
// pedido, a sombra vira para o outro lado (sempre recortada pela silhueta).
const rightOnScreen = p.mirror * Math.cos((p.rot * Math.PI) / 180);
const flipShadow = Math.sign(rightOnScreen || 1) !== Math.sign(light || 1);
const shadowT = flipShadow ? "translate(120 0) scale(-1 1)" : undefined;
const dark = shadeHex(skin, 0.62);
const shadow = coolHex(skin, 0.8);
const lineProps = { stroke: dark, strokeWidth: 1.7, strokeLinecap: "round" as const, strokeLinejoin: "round" as const, fill: "none", opacity: 0.55 };
const nail = ([cx, cy, rx, ry, a]: [number, number, number, number, number], i: number) => (
<ellipse key={i} cx={cx} cy={cy} rx={rx} ry={ry} transform={`rotate(${a} ${cx} ${cy})`} fill={mixHex(skin, "#f7cfc6", 0.55)} stroke={shadeHex(skin, 0.68)} strokeWidth={0.9} />
);
const bodyLayer = def.bodyBehind ? "back" : def.hold ? "front" : "all";
const showBody = layer === "all" || layer === bodyLayer || (bodyLayer === "all" && layer === "front");
const showOver = layer !== "back";
return (
<g transform={p.transform}>
<defs>
<clipPath id={`hb${uid}${layer}`}><path d={def.body} /></clipPath>
{def.over && <clipPath id={`ho${uid}${layer}`}><path d={def.over.body} /></clipPath>}
</defs>
{showBody && <>
<path d={def.body} fill={skin} />
<g clipPath={`url(#hb${uid}${layer})`}><path d={def.shadow} fill={shadow} transform={shadowT} /></g>
<path d={def.lines} {...lineProps} />
{(def.nails ?? []).map(nail)}
</>}
{showOver && def.over && <>
<path d={def.over.body} fill={shadeHex(skin, 1.03)} />
{def.over.shadow && <g clipPath={`url(#ho${uid}${layer})`}><path d={def.over.shadow} fill={shadow} /></g>}
{def.over.lines && <path d={def.over.lines} {...lineProps} />}
{(def.overNails ?? []).map(nail)}
</>}
</g>
);
}
+28
View File
@@ -70,6 +70,34 @@ const DRAW: Record<IconId, React.ReactNode> = {
<circle cx={50} cy={50} r={40} fill="#f4f6ff" /><circle cx={50} cy={50} r={34} fill="#232850" /> <circle cx={50} cy={50} r={40} fill="#f4f6ff" /><circle cx={50} cy={50} r={34} fill="#232850" />
<rect x={48} y={24} width={4} height={28} rx={2} fill="#fff" /><rect x={48} y={48} width={22} height={4} rx={2} fill={COLORS.key} /> <rect x={48} y={24} width={4} height={28} rx={2} fill="#fff" /><rect x={48} y={48} width={22} height={4} rx={2} fill={COLORS.key} />
</>), </>),
// Itens de mão e objetos de história antiga (também servem como objeto solto na cena).
olive: (<>
<path d="M20 86 Q46 60 86 16" stroke="#6b4a2a" strokeWidth={5} fill="none" strokeLinecap="round" />
{[[34, 66, -40], [44, 56, 30], [54, 46, -40], [64, 36, 30], [74, 26, -40], [28, 76, 30]].map(([x, y, r], i) => (
<ellipse key={i} cx={x} cy={y} rx={13} ry={5.5} fill={i % 2 ? "#7fa24a" : "#5f8a3a"} transform={`rotate(${r} ${x} ${y})`} />
))}
<circle cx={50} cy={58} r={4} fill="#3d3a5a" /><circle cx={70} cy={38} r={4} fill="#3d3a5a" />
</>),
hammer: (<>
<rect x={44} y={34} width={12} height={60} rx={5} fill="#8a5a32" transform="rotate(-20 50 64)" />
<rect x={22} y={14} width={50} height={22} rx={4} fill="#8c929e" transform="rotate(-20 47 25)" />
<rect x={22} y={14} width={12} height={22} rx={3} fill="#6c717c" transform="rotate(-20 47 25)" />
</>),
tablet: (<>
<path d="M18 10 Q50 4 82 10 L86 88 Q50 96 14 88 Z" fill="#b8916a" />
{Array.from({ length: 7 }, (_, i) => <path key={i} d={`M24 ${22 + i * 10} L76 ${22 + i * 10}`} stroke="#8a6646" strokeWidth={2.5} strokeDasharray="5 3 2 3" />)}
<path d="M70 70 L86 60 L86 88 L64 92 Z" fill="#000" opacity={0.18} />
</>),
book: (<>
<path d="M8 24 Q30 16 50 26 Q70 16 92 24 L92 82 Q70 74 50 84 Q30 74 8 82 Z" fill="#f2e8d0" />
<path d="M50 26 L50 84" stroke="#b9a882" strokeWidth={3} />
{[0, 1, 2, 3].map((i) => <g key={i}><path d={`M16 ${36 + i * 11} L42 ${38 + i * 11}`} stroke="#9a8a6a" strokeWidth={2.5} /><path d={`M58 ${38 + i * 11} L84 ${36 + i * 11}`} stroke="#9a8a6a" strokeWidth={2.5} /></g>)}
<path d="M8 82 Q30 74 50 84 Q70 74 92 82 L92 88 Q70 80 50 90 Q30 80 8 88 Z" fill="#7a3a2a" />
</>),
ruler: (<>
<rect x={6} y={38} width={88} height={24} rx={3} fill="#e6c27a" transform="rotate(-12 50 50)" />
{Array.from({ length: 10 }, (_, i) => <rect key={i} x={12 + i * 8.4} y={38} width={2.4} height={i % 2 ? 7 : 12} fill="#6b4a2a" transform="rotate(-12 50 50)" />)}
</>),
}; };
export function Icon({ id }: { id: IconId }) { export function Icon({ id }: { id: IconId }) {
+63
View File
@@ -0,0 +1,63 @@
// Profundidade dos braços do personagem de frente para a câmera (função pura do estado do rig, sem React).
//
// O desenho (CharacterFigure.tsx) empilha as camadas assim:
// tronco → braços "side" → acessórios do peito (toalha, cachecol, crachá, apito) → braços "front" →
// parte da toalha apoiada no ombro → cabeça → braços "face".
// Regra: com o personagem de frente, braço e mão NUNCA somem atrás do tronco, da roupa, de acessório ou da barba.
// - "face": a mão sobe até a altura do pescoço/rosto, dentro da largura da cabeça (pensar, tapar a boca, mão na
// testa) — desenhado por cima da cabeça e da barba;
// - "front": a mão ou o antebraço entram na frente do peito (segurar objeto diante do corpo, cruzar os braços,
// apontar para o outro lado, mão na cintura) — por cima do tronco e dos acessórios do peito;
// - "side": o braço fica ao lado do corpo (caído, acenando para fora, apontando para o lado) — por cima do tronco,
// mas por baixo do pano apoiado no ombro/peito (o braço sai por baixo da toalha).
// Não há caso "atrás do tronco": nenhuma pose do rig leva a mão às costas.
import type { BodyParams } from "./rig";
export type ArmLayer = "side" | "front" | "face";
export type Point = { x: number; y: number };
/** Ponta de um segmento: ângulo de tela em graus (0 = para baixo). Igual ao `tip` do desenho. */
export const tipOf = (x: number, y: number, deg: number, len: number): Point => {
const r = (deg * Math.PI) / 180;
return { x: x - Math.sin(r) * len, y: y + Math.cos(r) * len };
};
/** Medidas do desenho (viewBox 200×440) que a regra usa — as mesmas de CharacterFigure.tsx. */
export const ARM = { shoulderX: 54, upper: 56, wrist: 43, hand: 28, torsoHalf: 56 } as const;
/** Ombro, cotovelo, pulso e centro da mão do braço `s` (1 = direita da tela, -1 = esquerda). `w` = largura do corpo. */
export function armGeometry(b: BodyParams, s: 1 | -1, w = 1) {
const hipY = 306 + b.crouch * 56;
const shY = hipY - 100;
const torsoTop = hipY - 114;
const l = s > 0 ? b.armR : b.armL;
const shoulder = { x: 100 + s * ARM.shoulderX * w, y: shY };
const upperDeg = -s * l.raise;
const elbow = tipOf(shoulder.x, shoulder.y, upperDeg, ARM.upper);
const foreDeg = upperDeg + s * l.bend;
const wrist = tipOf(elbow.x, elbow.y, foreDeg, ARM.wrist);
const hand = tipOf(elbow.x, elbow.y, foreDeg, ARM.wrist + ARM.hand);
return { shoulder, elbow, wrist, hand, upperDeg, foreDeg, torsoTop, hipY };
}
/**
* Camada do braço `s` no quadro. `holds` = segura objeto (sempre na frente do corpo, salvo na altura do rosto).
* O "peito" é o tronco sem as faixas laterais onde o braço caído naturalmente encosta.
*/
export function armLayer(b: BodyParams, s: 1 | -1, opts: { holds?: boolean; w?: number } = {}): ArmLayer {
const w = opts.w ?? 1;
const g = armGeometry(b, s, w);
const half = ARM.torsoHalf * w;
// Altura do pescoço/rosto: acima do topo do tronco (+ folga da gola), dentro da largura da cabeça.
const atFace = (p: Point) => p.y < g.torsoTop + 12 && Math.abs(p.x - 100) < 66;
if (atFace(g.hand)) return "face";
if (opts.holds) return "front";
const chest = { x0: 100 - half + 16, x1: 100 + half - 16, y0: g.torsoTop + 6, y1: g.hipY + 10 };
const inChest = (p: Point) => p.x > chest.x0 && p.x < chest.x1 && p.y > chest.y0 && p.y < chest.y1;
// Amostra o antebraço (cotovelo → mão): basta um trecho na frente do peito.
for (let i = 0; i <= 8; i++) {
const k = i / 8;
if (inChest({ x: g.elbow.x + (g.hand.x - g.elbow.x) * k, y: g.elbow.y + (g.hand.y - g.elbow.y) * k })) return "front";
}
return "side";
}
+87
View File
@@ -0,0 +1,87 @@
// Boca acompanhando a fala SEM perder a expressão. O formato vem das letras da palavra que está sendo dita
// (tempos de cada palavra da transcrição): "a" abre, "e/i" esticam, "o/u" arredondam, "m/b/p" fecham, "f/v"
// mostram os dentes; vogal dura mais que consoante e as letras vizinhas se misturam (coarticulação). Se houver
// o volume do áudio quadro a quadro (`env`), ele fecha a boca nas pausas e abre mais nas sílabas fortes.
// A expressão continua por cima: os cantos (sorriso/tristeza), as sobrancelhas e os olhos são dela.
import type { FaceParams } from "./rig";
export type Viseme = { open: number; wide: number; round: number; teeth: boolean };
export type SpokenWord = { text: string; startS: number; endS: number };
const CLOSED: Viseme = { open: 0, wide: 0, round: 0, teeth: false };
const V: Record<string, Viseme> = {
a: { open: 0.85, wide: 0.3, round: 0, teeth: false },
e: { open: 0.55, wide: 0.65, round: 0, teeth: true },
i: { open: 0.3, wide: 0.95, round: 0, teeth: true },
o: { open: 0.65, wide: 0, round: 0.75, teeth: false },
u: { open: 0.35, wide: 0, round: 1, teeth: false },
mbp: { open: 0, wide: 0.1, round: 0, teeth: false },
fv: { open: 0.12, wide: 0.2, round: 0, teeth: true },
cons: { open: 0.3, wide: 0.3, round: 0, teeth: true },
};
function visemeOf(ch: string): Viseme {
if ("aáàâã".includes(ch)) return V.a;
if ("eéê".includes(ch)) return V.e;
if ("iíy".includes(ch)) return V.i;
if ("oóôõ".includes(ch)) return V.o;
if ("uúü".includes(ch)) return V.u;
if ("mbp".includes(ch)) return V.mbp;
if ("fv".includes(ch)) return V.fv;
return V.cons;
}
const isVowel = (ch: string) => /[aáàâãeéêiíyoóôõuúü]/.test(ch);
function mix(a: Viseme, b: Viseme, k: number): Viseme {
return { open: a.open + (b.open - a.open) * k, wide: a.wide + (b.wide - a.wide) * k, round: a.round + (b.round - a.round) * k, teeth: k < 0.5 ? a.teeth : b.teeth };
}
/** Formato da boca no instante `t` (segundos do trecho) para as palavras dadas; fechada fora das palavras. */
export function visemeAt(words: SpokenWord[], t: number, env?: { values: number[]; fps: number }): Viseme {
const w = words.find((x) => t >= x.startS && t < x.endS);
if (!w) {
// Fim de palavra: fecha em ~60 ms em vez de bater a boca.
const prev = [...words].reverse().find((x) => x.endS <= t);
return prev && t - prev.endS < 0.06 ? mix(V.cons, CLOSED, (t - prev.endS) / 0.06) : CLOSED;
}
const letters = [...w.text.toLowerCase().replace(/(ch|lh|nh|qu)/g, "c").replace(/[^a-záàâãéêíóôõúüçy]/g, "")];
if (!letters.length) return CLOSED;
// Vogal pesa o dobro da consoante no tempo da palavra.
const weights = letters.map((ch) => (isVowel(ch) ? 1.7 : 0.8));
const total = weights.reduce((a, b) => a + b, 0);
let pos = ((t - w.startS) / Math.max(0.04, w.endS - w.startS)) * total;
let i = 0;
while (i < letters.length - 1 && pos > weights[i]) { pos -= weights[i]; i++; }
const frac = Math.min(1, pos / weights[i]);
const cur = visemeOf(letters[i]);
const next = i + 1 < letters.length ? visemeOf(letters[i + 1]) : CLOSED;
// Coarticulação: a 2ª metade da letra já caminha para a próxima.
let v = frac > 0.5 ? mix(cur, next, (frac - 0.5) * 0.9) : cur;
if (env?.values.length) {
const a = env.values[Math.min(env.values.length - 1, Math.max(0, Math.floor(t * env.fps)))] ?? 0;
const k = Math.max(0, Math.min(1.15, (a - 0.03) / 0.3));
v = { ...v, open: v.open * (0.25 + 0.75 * Math.min(1, k)) * (k < 0.05 ? 0.2 : 1) };
}
return v;
}
/** Ênfase (0–1) no instante: o volume perto do pico levanta um pouco as sobrancelhas. */
export function emphasisAt(t: number, env?: { values: number[]; fps: number }): number {
if (!env?.values.length) return 0;
const a = env.values[Math.min(env.values.length - 1, Math.max(0, Math.floor(t * env.fps)))] ?? 0;
return Math.max(0, Math.min(1, (a - 0.45) / 0.4));
}
/** Põe a fala na boca mantendo a expressão (cantos, sobrancelhas, olhos). `k` = quanto da fala entra (0–1). */
export function speak(face: FaceParams, v: Viseme, k = 1, emphasis = 0): FaceParams {
const open = Math.max(face.mouthOpen * 0.35, v.open * 0.9);
return {
...face,
mouthOpen: face.mouthOpen + (open - face.mouthOpen) * k,
mouthWidth: face.mouthWidth * (1 + (v.wide * 0.22 - v.round * 0.45) * k),
mouthRound: face.mouthRound + (v.round - face.mouthRound) * k,
teeth: k > 0.5 ? v.teeth && v.open > 0.1 : face.teeth,
browL: { ...face.browL, y: face.browL.y - emphasis * 3 * k },
browR: { ...face.browR, y: face.browR.y - emphasis * 3 * k },
};
}
+222
View File
@@ -0,0 +1,222 @@
// Movimento do personagem: uma LINHA DO TEMPO de ações que se combinam (não animações prontas). Cada ação tem
// início (segundos `at`, fração do trecho `atP` ou a palavra da narração `cue`) e duração; o estado em cada
// quadro sai de aplicar as ações em ordem sobre a expressão/pose de base, mais a "vida" (piscar, respirar).
// Ações permanentes mudam o estado dali em diante (express, pose, walk, sit, fall, turn, look); as momentâneas
// voltam ao fim (nod, shake_head, tremble, bounce, wave, jump, talk, emote).
import { emphasisAt, speak, visemeAt, type SpokenWord } from "./lipsync";
import { blendBody, blendFace, bodyOf, faceOf, withBody, withFace, type BodyParams, type BodyPatch, type FaceParams, type FacePatch } from "./rig";
export const ACTIONS = ["express", "pose", "walk", "run", "enter", "exit", "jump", "nod", "shake_head", "tremble", "bounce", "fall",
"sit", "stand_up", "turn", "talk", "look", "emote", "wave", "hammer"] as const;
export type ActionKind = (typeof ACTIONS)[number];
export type Action = {
do: ActionKind;
/** Início: segundos, fração do trecho (0–1) ou a 1ª palavra da narração que começa com `cue`. */
at?: number; atP?: number; cue?: string;
dur?: number;
/** talk: termina no fim desta palavra da narração (a fala vai de `cue` até `cueEnd`). */
cueEnd?: string;
expression?: string; face?: FacePatch;
pose?: string; body?: BodyPatch;
/** walk/run/enter: x de destino (fração). */
to?: number;
/** look: para onde; fall: para que lado. */
dir?: "left" | "right" | "up" | "down";
/** nod/shake_head/bounce/wave: repetições. jump: altura (fração da altura do quadro). */
times?: number; height?: number;
/** emote: símbolo sobre a cabeça ("!", "?", "…", "♥", "zzz", "💢"). talk: o texto falado (sem tempos de palavra, é
* repartido pela duração). */
text?: string;
};
export type ActorInput = {
x: number; expression?: string; pose?: string; face?: FacePatch; body?: BodyPatch; flip?: boolean; timeline?: Action[];
};
export type ActorState = {
face: FaceParams; body: BodyParams;
x: number; dy: number; dx: number; rot: number; sx: number; sy: number; flip: boolean;
emote: { text: string; k: number } | null;
};
const DEFAULT_DUR: Record<ActionKind, number> = {
express: 0.25, pose: 0.35, walk: 1.6, run: 0.9, enter: 1.2, exit: 1.2, jump: 0.8, nod: 0.7, shake_head: 0.8, tremble: 1, bounce: 0.8,
fall: 0.6, sit: 0.5, stand_up: 0.5, turn: 0.3, talk: 1.5, look: 0.3, emote: 1.2, wave: 1.2, hammer: 2.4,
};
const clamp01 = (v: number) => Math.max(0, Math.min(1, v));
const ease = (p: number) => (p < 0.5 ? 2 * p * p : 1 - (-2 * p + 2) ** 2 / 2);
/** Passa um pouco do alvo e volta (dá vida às poses). */
const easeBack = (p: number) => { const c = 1.4; return 1 + (c + 1) * (p - 1) ** 3 + c * (p - 1) ** 2; };
const norm = (s: string) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]/g, "");
/** Início da ação em segundos (cue = palavra falada; sem a palavra, cai para atP/at/0). */
export function startOf(a: Action, durationS: number, words: { text: string; startS: number }[] = []): number {
if (a.cue) {
const c = norm(a.cue);
const w = words.find((x) => norm(x.text).startsWith(c));
if (w) return w.startS;
}
if (a.atP !== undefined) return a.atP * durationS;
return a.at ?? 0;
}
/** Piscar em intervalos variados (2,4–4,6 s), determinístico pela semente. */
function blinkAt(t: number, seed: number): number {
let s = 0.6 + (seed % 7) * 0.13;
let k = 1;
while (s < t + 0.2) {
const d = t - s;
if (d >= 0 && d < 0.13) k = Math.min(k, Math.abs(d - 0.065) / 0.065);
s += 2.4 + ((Math.sin(s * 12.9898 + seed) + 1) / 2) * 2.2;
}
return k;
}
/** Fala do trecho: palavras com tempo (narração) e, se houver, o volume do áudio quadro a quadro. */
export type Speech = { words: SpokenWord[]; env?: { values: number[]; fps: number } };
/** Fim da fala: o fim da palavra `cueEnd` (depois do início), senão início + dur. */
function endOf(a: Action, s: number, words: SpokenWord[]): number | null {
if (!a.cueEnd) return null;
const c = norm(a.cueEnd);
const w = words.find((x) => x.startS >= s - 0.01 && norm(x.text).startsWith(c));
return w ? w.endS : null;
}
export function evaluate(actor: ActorInput, t: number, durationS: number, seed = 1, speech: Speech = { words: [] }): ActorState {
const words = speech.words;
const st: ActorState = {
face: faceOf(actor.expression, actor.face), body: bodyOf(actor.pose, actor.body),
x: actor.x, dy: 0, dx: 0, rot: 0, sx: 1, sy: 1, flip: !!actor.flip, emote: null,
};
const timeline = (actor.timeline ?? []).map((a) => ({ a, s: startOf(a, durationS, words) })).sort((p, q) => p.s - q.s);
for (const { a, s } of timeline) {
if (t < s) break;
const end = a.do === "talk" ? endOf(a, s, words) : null;
const d = Math.max(0.05, end !== null ? end - s : a.dur ?? DEFAULT_DUR[a.do]);
const p = clamp01((t - s) / d);
const active = t - s < d;
const env = active ? Math.min(1, (t - s) / 0.15, (s + d - t) / 0.15) : 0; // entra e sai suave (momentâneas)
switch (a.do) {
case "express": {
const target = a.expression ? faceOf(a.expression, a.face) : withFace(st.face, a.face);
st.face = blendFace(st.face, target, ease(p));
break;
}
case "pose": {
const target = a.pose ? bodyOf(a.pose, a.body) : withBody(st.body, a.body);
st.body = blendBody(st.body, target, clamp01(easeBack(p)));
break;
}
case "walk": case "run": case "enter": case "exit": {
const from = a.do === "enter" ? (a.to ?? st.x) < 0.5 ? -0.25 : 1.25 : st.x;
const to = a.do === "exit" ? (st.x < 0.5 ? -0.3 : 1.3) : a.to ?? st.x;
const run = a.do === "run";
st.x = from + (to - from) * (run ? p : ease(p));
if (to !== from) st.flip = to < from;
if (active) {
const phase = (t - s) * Math.PI * 2 * (run ? 3.2 : 2.1);
const amp = run ? 1.6 : 1;
const sw = Math.sin(phase);
st.body = withBody(st.body, {
armL: { raise: 8 + sw * 20 * amp, bend: run ? 85 : 15 }, armR: { raise: 8 - sw * 20 * amp, bend: run ? 85 : 15 },
legL: { raise: 3 + Math.max(0, sw) * 6, bend: Math.max(0, sw) * 38 * amp }, legR: { raise: 3 + Math.max(0, -sw) * 6, bend: Math.max(0, -sw) * 38 * amp },
lean: (to < from ? -1 : 1) * (run ? 8 : 3),
});
st.dy -= Math.abs(Math.sin(phase)) * (run ? 0.012 : 0.006);
}
break;
}
case "jump": {
if (!active) break;
const h = a.height ?? 0.08;
if (p < 0.15) { st.sy *= 1 - 0.1 * (p / 0.15); st.sx *= 1 + 0.06 * (p / 0.15); st.body = withBody(st.body, { crouch: 0.35 * (p / 0.15) }); }
else if (p < 0.85) {
const q = (p - 0.15) / 0.7;
st.dy -= h * 4 * q * (1 - q);
st.sy *= 1.07; st.sx *= 0.95;
st.body = withBody(st.body, { arms: { raise: 120, bend: -10 }, legs: { raise: 6, bend: 30 } });
} else { const q = (p - 0.85) / 0.15; st.sy *= 1 - 0.08 * (1 - q); st.sx *= 1 + 0.05 * (1 - q); }
break;
}
case "nod": st.body = withBody(st.body, { headNod: st.body.headNod + Math.sin(p * Math.PI * 2 * (a.times ?? 2)) * 0.6 * env }); break;
case "shake_head": st.body = withBody(st.body, { headTurn: st.body.headTurn + Math.sin(p * Math.PI * 2 * (a.times ?? 2)) * 0.7 * env }); break;
case "tremble": if (active) { st.dx += Math.sin(t * 77.7) * 0.004 * env; st.dy += Math.cos(t * 91.3) * 0.002 * env; } break;
case "bounce": st.dy -= Math.abs(Math.sin(p * Math.PI * (a.times ?? 2))) * 0.02 * env; break;
case "fall": {
const side = a.dir === "right" ? 1 : -1;
st.rot = side * 88 * ease(p);
st.dy += 0.02 * ease(p);
st.face = blendFace(st.face, faceOf("shocked"), Math.min(1, p * 3));
break;
}
case "sit": st.body = blendBody(st.body, withBody(st.body, { crouch: 1, arms: { raise: 14, bend: 40 } }), ease(p)); break;
case "stand_up": st.body = blendBody(st.body, withBody(st.body, { crouch: 0 }), ease(p)); break;
case "turn": {
const flipped = !st.flip;
if (p >= 0.5) st.flip = flipped;
if (active) st.sx *= Math.max(0.15, Math.abs(Math.cos(p * Math.PI)));
break;
}
case "talk": {
if (!active) break;
// Palavras da narração dentro da fala; sem elas, o texto da ação repartido pela duração (vogal pesa mais).
let spoken = words.filter((w) => w.endS > s && w.startS < s + d);
if (!spoken.length && a.text) {
const list = a.text.split(/\s+/).filter(Boolean);
const total = list.reduce((n, w) => n + w.length + 1, 0);
let c = s;
spoken = list.map((w) => { const len = (d * (w.length + 1)) / total; const out = { text: w, startS: c, endS: c + len * 0.88 }; c += len; return out; });
}
if (spoken.length) {
st.face = speak(st.face, visemeAt(spoken, t, speech.env), Math.min(1, (t - s) / 0.08, (s + d - t) / 0.08 + 0.2), emphasisAt(t, speech.env));
} else {
const flap = Math.abs(Math.sin((t - s) * Math.PI * 2 * 4.3 + seed)) * (0.6 + 0.4 * Math.sin((t - s) * 9.1 + seed));
st.face = { ...st.face, mouthOpen: Math.max(st.face.mouthOpen, (0.12 + 0.5 * flap) * env), teeth: st.face.teeth || flap > 0.6 };
}
// Quem fala mexe a cabeça de leve e acompanha as sílabas fortes.
st.body = withBody(st.body, { headTilt: st.body.headTilt + Math.sin((t - s) * 5.3) * 2 * env, headNod: st.body.headNod + emphasisAt(t, speech.env) * 0.25 });
break;
}
case "look": {
const gx = a.dir === "left" ? -0.9 : a.dir === "right" ? 0.9 : 0;
const gy = a.dir === "up" ? -0.8 : a.dir === "down" ? 0.8 : 0;
const k = ease(p);
st.face = { ...st.face, gazeX: st.face.gazeX + (gx - st.face.gazeX) * k, gazeY: st.face.gazeY + (gy - st.face.gazeY) * k };
st.body = withBody(st.body, { headTurn: st.body.headTurn + (gx * 0.5 - st.body.headTurn) * k, headNod: st.body.headNod + (gy * -0.4 - st.body.headNod) * k });
break;
}
case "emote": if (active) st.emote = { text: a.text ?? "!", k: env }; break;
// Martelar: braço direito sobe e desce batendo (`times` golpes), cabeça acompanha cada batida.
case "hammer": if (active) {
const beat = Math.abs(Math.sin(p * Math.PI * (a.times ?? 5)));
st.body = withBody(st.body, { armR: { raise: 40 + beat * 95 * Math.min(1, env * 1.5), bend: 60 + beat * 40 }, headNod: st.body.headNod + (1 - beat) * 0.15 * env });
break;
}
case "wave": if (active) st.body = withBody(st.body, { armR: { raise: 140 * Math.min(1, env * 1.5), bend: -25 + Math.sin(p * Math.PI * 2 * (a.times ?? 3)) * 30 } }); break;
}
}
// Vida: piscar (a não ser de olhos quase fechados), respirar e um balanço leve de cabeça.
const blink = blinkAt(t, seed);
if (blink < 1) st.face = { ...st.face, eyeL: st.face.eyeL * Math.max(0.08, blink), eyeR: st.face.eyeR * Math.max(0.08, blink) };
st.body = withBody(st.body, { headTilt: st.body.headTilt + Math.sin(t * 0.9 + seed) * 1.2 });
return st;
}
/** Confere uma linha do tempo (lista de problemas; vazia = ok). */
export function validateTimeline(timeline: unknown): string[] {
if (timeline === undefined) return [];
if (!Array.isArray(timeline) || timeline.length > 40) return ["timeline: lista de até 40 ações"];
const errors: string[] = [];
timeline.forEach((a: Partial<Action>, i) => {
if (!a || !ACTIONS.includes(a.do as ActionKind)) errors.push(`timeline[${i}].do: ${ACTIONS.join(", ")}`);
for (const k of ["at", "atP", "dur", "to", "times", "height"] as const) {
if (a[k] !== undefined && (typeof a[k] !== "number" || !Number.isFinite(a[k]))) errors.push(`timeline[${i}].${k}: número`);
}
if (a.atP !== undefined && !(a.atP >= 0 && a.atP <= 1)) errors.push(`timeline[${i}].atP entre 0 e 1`);
if (a.dur !== undefined && !(a.dur > 0 && a.dur <= 30)) errors.push(`timeline[${i}].dur entre 0 e 30 s`);
});
return errors;
}
+343 -33
View File
@@ -1,9 +1,13 @@
// Camadas por cima da cena: etiqueta, onomatopeia, contador, ondas de som, X vermelho, painel do topo (HUD) e a // Camadas por cima da cena: etiqueta, onomatopeia, ondas de som, X vermelho, painel do topo (HUD), cartão de nome,
// legenda palavra por palavra (cada palavra entra pequena e cresce; palavra-chave em amarelo, perigo em vermelho). // cartelas de dado (número grande, lista com caixas, tabela, barra de progresso, grade de quadradinhos) e a legenda
// palavra por palavra (cada palavra entra pequena e cresce; palavra-chave maior e em amarelo, perigo em vermelho).
//
// Tudo é função pura do quadro (mola da Remotion + tempo do spec): o mesmo quadro sai sempre igual.
// Tamanhos em `u(n)` = n% da largura de um quadro vertical 9:16 (num quadro mais largo, limita pela altura).
import React from "react"; import React from "react";
import { spring } from "remotion"; import { spring } from "remotion";
import { COLORS, FONT_CAPTION, FONT_LABEL, TONE_BG, TONE_FG } from "./theme"; import { COLORS, FONT_CAPTION, FONT_LABEL, FONT_TEXT, TONE_BG, TONE_FG } from "./theme";
import type { ShotSpec, TextItem, Tone, Word } from "./spec"; import { numberOf, type Hud as HudSpec, type TextItem, type TextRow, type Tone, type Word } from "./spec";
/** 0 → 1 com mola, a partir de `startS` (antes disso, 0). */ /** 0 → 1 com mola, a partir de `startS` (antes disso, 0). */
export function pop(frame: number, fps: number, startS = 0, stiffness = 220): number { export function pop(frame: number, fps: number, startS = 0, stiffness = 220): number {
@@ -16,6 +20,32 @@ export function shake(frame: number, amp = 3): { x: number; y: number } {
return { x: Math.sin(frame * 12.9898) * amp, y: Math.cos(frame * 78.233) * amp * 0.7 }; return { x: Math.sin(frame * 12.9898) * amp, y: Math.cos(frame * 78.233) * amp * 0.7 };
} }
/** 0 → 1 sem mola (desacelera no fim), de `startS` a `startS + durS`: barra enchendo, número contando. */
export function ease(frame: number, fps: number, startS: number, durS: number): number {
const p = Math.max(0, Math.min(1, (frame / fps - startS) / Math.max(0.01, durS)));
return 1 - (1 - p) ** 3;
}
/** Medida proporcional ao quadro: n% da largura de um vertical 9:16. */
export const u = (n: number) => `calc(${n.toFixed(3)} * min(1cqw, 0.5625cqh))`;
/** Cores do grafismo (cartelas, HUD, cartão de nome). */
export const UI = {
ink: "#151a31",
box: "rgba(15,18,30,0.94)",
boxEdge: "rgba(150,160,210,0.16)",
cell: "#252c48",
cream: "#f3efe6",
yellow: "#fcc430",
red: "#ea4752",
redSoft: "#f4646d",
green: "#2f9a55",
muted: "#c3c8dd",
dim: "#7f87a8",
track: "#2a3050",
};
const TONE_TEXT: Record<Tone, string> = { danger: UI.red, info: UI.yellow, ok: "#45c97a" };
const at = (x: number, y: number): React.CSSProperties => ({ position: "absolute", left: `${x * 100}%`, top: `${y * 100}%` }); const at = (x: number, y: number): React.CSSProperties => ({ position: "absolute", left: `${x * 100}%`, top: `${y * 100}%` });
export function TagLabel({ text, tone = "info", size = 3.6 }: { text: string; tone?: Tone; size?: number }) { export function TagLabel({ text, tone = "info", size = 3.6 }: { text: string; tone?: Tone; size?: number }) {
@@ -28,24 +58,244 @@ export function TagLabel({ text, tone = "info", size = 3.6 }: { text: string; to
); );
} }
export function TextLayer({ t, frame, fps }: { t: TextItem; frame: number; fps: number }) { /**
const k = pop(frame, fps, t.atS ?? 0); * Cartão de nome do personagem: cartão creme arredondado, nome grande em letra condensada escura e 1–2 linhas
if (k <= 0.001) return null; * menores (função, dado). Sem posição nem animação: quem usa posiciona e faz a entrada.
const base = { ...at(t.x, t.y), transform: `translate(-50%, -50%) rotate(${t.rotate ?? 0}deg) scale(${0.4 + 0.6 * k})`, opacity: Math.min(1, k * 1.4) }; */
if (t.kind === "tag") return <div style={base}><TagLabel text={t.text} tone={t.tone} /></div>; export function NameCard({ name, lines = [], size = 1 }: { name: string; lines?: string[]; size?: number }) {
if (t.kind === "counter") { const s = size;
return ( return (
<div style={{ ...base, textAlign: "center", border: "0.35cqw solid #fff", borderRadius: "1.4cqw", padding: "0.8cqw 2.6cqw", <div style={{ display: "inline-block", background: UI.cream, borderRadius: u(2.4 * s), padding: `${u(2.2 * s)} ${u(3.4 * s)} ${u(2.5 * s)}`,
background: "rgba(10,12,28,0.85)" }}> boxShadow: `0 ${u(0.9 * s)} 0 rgba(8,10,22,0.34)`, textAlign: "left", whiteSpace: "nowrap" }}>
<div style={{ fontFamily: FONT_LABEL, fontSize: "2.6cqw", color: "#c9cbe0", letterSpacing: "0.08em" }}>{t.text.toUpperCase()}</div> <div style={{ fontFamily: FONT_CAPTION, fontSize: u(6 * s), color: UI.ink, lineHeight: 1.12, letterSpacing: "0.005em" }}>{name.toUpperCase()}</div>
<div style={{ fontFamily: FONT_CAPTION, fontSize: "8cqw", color: "#fff", lineHeight: 1 }}>{t.value ?? ""}</div> {lines.filter((l) => l.trim()).slice(0, 3).map((l, i) => (
<div key={i} style={{ fontFamily: FONT_TEXT, fontSize: u(3.3 * s), color: "#1c2138", lineHeight: 1.55, letterSpacing: "0.035em",
marginTop: i === 0 ? u(0.3 * s) : 0 }}>
{l.toUpperCase()}
</div>
))}
</div> </div>
); );
} }
const s = t.kind === "onomatopoeia" ? shake(frame, 4) : { x: 0, y: 0 };
/** Conta o número do texto de 0 até o valor ("R$ 134.273", "-R$ 47.312.904", "297"), mantendo prefixo e sufixo. */
export function countUp(value: string, p: number): string {
const m = /^(\D*?)(\d{1,3}(?:\.\d{3})+|\d+)(,\d+)?(\D*)$/.exec(value.trim());
if (!m || p >= 1) return value;
const target = Number(m[2].replace(/\./g, ""));
if (target < 10) return value;
const n = String(Math.round(target * Math.max(0, p)));
const digits = m[2].includes(".") ? n.replace(/\B(?=(\d{3})+(?!\d))/g, ".") : n;
return `${m[1]}${digits}${m[3] ?? ""}${m[4]}`;
}
/** Caixa escura arredondada das cartelas flutuantes. */
function Box({ s, children, style }: { s: number; children: React.ReactNode; style?: React.CSSProperties }) {
return (
<div style={{ background: UI.box, borderRadius: u(3 * s), border: `${u(0.22 * s)} solid ${UI.boxEdge}`,
boxShadow: `0 ${u(0.8 * s)} 0 rgba(0,0,0,0.3)`, ...style }}>
{children}
</div>
);
}
/** Fundo escuro de tela inteira (cartela "panel"), com leve luz no centro como a referência. */
function PanelBackdrop({ k }: { k: number }) {
return (
<div style={{ position: "absolute", inset: "-4%", opacity: Math.min(1, k * 2.2),
background: "radial-gradient(ellipse 62% 42% at 50% 46%, #1d2342 0%, #151a31 55%, #0e1222 100%)" }} />
);
}
const label = (size: number, color = UI.muted, spacing = 0.16): React.CSSProperties => ({
fontFamily: FONT_TEXT, fontSize: u(size), color, letterSpacing: `${spacing}em`, lineHeight: 1.1, whiteSpace: "nowrap",
});
function StatCard({ t, s, frame, fps }: { t: TextItem; s: number; frame: number; fps: number }) {
const atS = t.atS ?? 0;
const value = countUp(String(t.value ?? ""), ease(frame, fps, atS + 0.1, 0.9));
const inner = (
<div style={{ textAlign: "center" }}>
{t.text.trim() && <div style={{ ...label(4.4 * s), marginBottom: u(1.2 * s), paddingLeft: "0.16em" }}>{t.text.toUpperCase()}</div>}
<div style={{ fontFamily: FONT_CAPTION, fontSize: u(15.5 * s), lineHeight: 1.08, whiteSpace: "nowrap",
color: t.tone ? TONE_TEXT[t.tone] : "#ffffff", textShadow: `0 ${u(0.6 * s)} 0 rgba(0,0,0,0.3)` }}>{value.toUpperCase()}</div>
</div>
);
return t.panel ? inner : <Box s={s} style={{ padding: `${u(2.6 * s)} ${u(5 * s)} ${u(2 * s)}` }}>{inner}</Box>;
}
function CounterCard({ t, s, frame, fps }: { t: TextItem; s: number; frame: number; fps: number }) {
const value = countUp(String(t.value ?? ""), ease(frame, fps, (t.atS ?? 0) + 0.1, 0.8));
return (
<Box s={s} style={{ padding: `${u(2.2 * s)} ${u(4.6 * s)} ${u(1.4 * s)}`, textAlign: "center", borderRadius: u(2.8 * s) }}>
<div style={{ ...label(3.5 * s, UI.muted, 0.12), paddingLeft: "0.12em" }}>{t.text.toUpperCase()}</div>
<div style={{ fontFamily: FONT_CAPTION, fontSize: u(11 * s), color: t.tone ? TONE_TEXT[t.tone] : "#ffffff", lineHeight: 1.12 }}>{value}</div>
</Box>
);
}
/** Caixa de seleção: vazia (contorno), marcada (verde enche da esquerda e o ✓ se desenha) ou riscada (vermelha com X). */
function CheckBox({ state, m, s }: { state: TextRow["state"]; m: number; s: number }) {
const side = u(8.2 * s);
const fill = state === "crossed" ? UI.red : UI.green;
const marked = state === "checked" || state === "crossed";
const draw = Math.max(0, Math.min(1, (m - 0.45) / 0.55));
return (
<div style={{ position: "relative", width: side, height: side, flex: "none", borderRadius: u(1.6 * s), overflow: "hidden",
boxSizing: "border-box", border: `${u(0.7 * s)} solid ${marked && m > 0 ? fill : state === "empty" ? "#4d5476" : "#6d7598"}` }}>
{marked && m > 0 && <div style={{ position: "absolute", left: 0, top: 0, bottom: 0, width: `${Math.min(1, m * 1.8) * 100}%`, background: fill }} />}
{marked && draw > 0 && (
<svg viewBox="0 0 100 100" style={{ position: "absolute", inset: "-12%", width: "124%", height: "124%" }}>
{state === "checked"
? <path d="M27 52 L44 68 L74 34" fill="none" stroke="#fff" strokeWidth={12} strokeLinecap="round" strokeLinejoin="round"
strokeDasharray={80} strokeDashoffset={80 * (1 - draw)} />
: <g stroke="#fff" strokeWidth={12} strokeLinecap="round">
<line x1={34} y1={34} x2={34 + 32 * Math.min(1, draw * 2)} y2={34 + 32 * Math.min(1, draw * 2)} />
{draw > 0.5 && <line x1={66} y1={34} x2={66 - 32 * (draw - 0.5) * 2} y2={34 + 32 * (draw - 0.5) * 2} />}
</g>}
</svg>
)}
</div>
);
}
function ChecklistCard({ t, s, frame, fps }: { t: TextItem; s: number; frame: number; fps: number }) {
const atS = t.atS ?? 0;
const step = t.stepS ?? 0.5;
const items = t.items ?? [];
let order = 0;
return (
<Box s={s} style={{ padding: `${u(5 * s)} ${u(7 * s)} ${u(5 * s)} ${u(6.4 * s)}`, minWidth: u((t.panel ? 84 : 30) * s), boxSizing: "border-box",
...(t.panel ? { background: "rgba(9,11,22,0.6)", boxShadow: "none" } : {}) }}>
{t.text.trim() && <div style={{ ...label(3.8 * s), marginBottom: u(3 * s) }}>{t.text.toUpperCase()}</div>}
{items.map((it, i) => {
const kIn = pop(frame, fps, atS + i * 0.07, 260);
const marked = it.state === "checked" || it.state === "crossed";
// Marcadas e riscadas em sequência, na ordem da lista.
const m = marked ? ease(frame, fps, atS + 0.45 + step * order++, 0.38) : 0;
const color = it.state === "crossed" && m > 0.5 ? UI.redSoft : marked && m > 0.5 ? "#ffffff" : it.state === "empty" ? UI.dim : UI.muted;
return (
<div key={i} style={{ display: "flex", alignItems: "center", gap: u(4 * s), marginTop: i ? u(3.3 * s) : 0,
opacity: Math.min(1, kIn * 1.6), transform: `translateX(${(1 - kIn) * -6}%)` }}>
<CheckBox state={it.state ?? "empty"} m={m} s={s} />
<span style={{ ...label(6.1 * s, color, 0.05) }}>{it.text.toUpperCase()}</span>
</div>
);
})}
</Box>
);
}
function TableCard({ t, s, frame, fps }: { t: TextItem; s: number; frame: number; fps: number }) {
const atS = t.atS ?? 0;
const items = t.items ?? [];
const hl = t.highlight;
const hlK = hl === undefined ? 0 : pop(frame, fps, atS + 0.35 + items.length * 0.1, 200);
const hlColor = t.tone === "ok" ? UI.green : t.tone === "info" ? UI.yellow : UI.red;
return (
<Box s={s} style={{ padding: `${u(3.8 * s)} ${u(3.6 * s)}`, width: u(80 * s), boxSizing: "border-box" }}>
{t.text.trim() && <div style={{ ...label(3.8 * s), marginBottom: u(2.2 * s), paddingLeft: u(1.6 * s) }}>{t.text.toUpperCase()}</div>}
{items.map((it, i) => {
const kIn = pop(frame, fps, atS + 0.1 + i * 0.1, 260);
const on = i === hl;
const fg = on && hlK > 0.5 ? (t.tone === "info" ? UI.ink : "#ffffff") : "#ffffff";
return (
<div key={i} style={{ position: "relative", display: "flex", alignItems: "center", gap: u(2.6 * s), padding: `${u(1.5 * s)} ${u(2.2 * s)}`,
borderTop: i ? `${u(0.2 * s)} solid rgba(255,255,255,0.07)` : "none", opacity: Math.min(1, kIn * 1.6),
transform: `translateY(${(1 - kIn) * 25}%) scale(${on ? 1 + 0.04 * hlK : 1})` }}>
{on && <div style={{ position: "absolute", inset: `${u(-0.3 * s)} ${u(-1 * s)}`, borderRadius: u(1.4 * s), background: hlColor, opacity: hlK,
boxShadow: `0 ${u(0.5 * s)} 0 rgba(0,0,0,0.3)` }} />}
<span style={{ position: "relative", fontFamily: FONT_CAPTION, fontSize: u(4.6 * s), color: on && hlK > 0.5 ? fg : UI.dim, width: u(4.4 * s), lineHeight: 1.15 }}>{i + 1}</span>
<span style={{ position: "relative", ...label(5 * s, fg, 0.04), flex: 1, overflow: "hidden", textOverflow: "ellipsis" }}>{it.text.toUpperCase()}</span>
{it.value !== undefined && <span style={{ position: "relative", fontFamily: FONT_CAPTION, fontSize: u(5.2 * s), color: fg, lineHeight: 1.15 }}>{it.value.toUpperCase()}</span>}
</div>
);
})}
</Box>
);
}
function ProgressCard({ t, s, frame, fps }: { t: TextItem; s: number; frame: number; fps: number }) {
const target = Math.max(0, Math.min(100, numberOf(t.value)));
const f = ease(frame, fps, (t.atS ?? 0) + 0.25, 1.1);
const pct = Math.round(target * f);
const color = t.tone ? TONE_TEXT[t.tone] : UI.yellow;
return (
<Box s={s} style={{ padding: `${u(2.6 * s)} ${u(3.6 * s)} ${u(3 * s)}`, width: u(82 * s), boxSizing: "border-box" }}>
<div style={{ display: "flex", justifyContent: "space-between", alignItems: "baseline" }}>
<span style={{ ...label(4 * s, "#ffffff", 0.12) }}>{t.text.toUpperCase()}</span>
<span style={{ fontFamily: FONT_CAPTION, fontSize: u(5.6 * s), color, lineHeight: 1.1 }}>{pct}%</span>
</div>
<div style={{ marginTop: u(1.6 * s), height: u(2.6 * s), borderRadius: u(1.3 * s), background: UI.track, overflow: "hidden" }}>
<div style={{ height: "100%", width: `${target * f}%`, borderRadius: u(1.3 * s), background: color,
boxShadow: `inset 0 ${u(0.6 * s)} 0 rgba(255,255,255,0.28)` }} />
</div>
</Box>
);
}
function GridCard({ t, s, frame, fps }: { t: TextItem; s: number; frame: number; fps: number }) {
const atS = t.atS ?? 0;
const total = Math.max(1, Math.min(40, Math.round(t.total ?? 1)));
const filled = Math.max(0, Math.min(total, Math.round(numberOf(t.value) || 0)));
const cols = total <= 6 ? total : total <= 24 ? 6 : 8;
const side = 7.4 * s;
return (
<Box s={s} style={{ padding: `${u(3.4 * s)} ${u(4 * s)} ${u(3.2 * s)}` }}>
<div style={{ fontFamily: FONT_CAPTION, fontSize: u(6.4 * s), color: "#ffffff", lineHeight: 1.15, marginBottom: u(2.2 * s), whiteSpace: "nowrap" }}>{t.text.toUpperCase()}</div>
<div style={{ display: "grid", gridTemplateColumns: `repeat(${cols}, ${u(side)})`, gap: u(1.3 * s) }}>
{Array.from({ length: total }, (_, i) => {
const k = i < filled ? pop(frame, fps, atS + 0.35 + i * 0.14, 260) : 0;
return (
<div key={i} style={{ position: "relative", width: u(side), height: u(side), boxSizing: "border-box", borderRadius: u(1 * s),
border: `${u(0.45 * s)} solid #3a4166` }}>
{k > 0.001 && (
<div style={{ position: "absolute", inset: u(-0.45 * s), borderRadius: u(1 * s), background: UI.cream, transform: `scale(${0.4 + 0.6 * k})`,
opacity: Math.min(1, k * 1.8), display: "flex", alignItems: "center", justifyContent: "center",
fontFamily: FONT_CAPTION, fontSize: u(4.4 * s), color: UI.ink, lineHeight: 1 }}>{i + 1}</div>
)}
</div>
);
})}
</div>
<div style={{ ...label(3.6 * s, UI.yellow, 0.12), marginTop: u(2.4 * s) }}>{filled} DE {total}</div>
</Box>
);
}
const CARDS = { stat: StatCard, counter: CounterCard, checklist: ChecklistCard, table: TableCard, progress: ProgressCard, grid: GridCard } as const;
export function TextLayer({ t, frame, fps }: { t: TextItem; frame: number; fps: number }) {
const k = pop(frame, fps, t.atS ?? 0);
if (k <= 0.001) return null;
const s = t.size ?? 1;
if (t.kind === "namecard") {
// Entra deslizando do lado de fora do quadro, com mola.
const dir = t.x < 0.5 ? -1 : 1;
return (
<div style={{ ...at(t.x, t.y), transform: `translate(-50%, -50%) translateX(${dir * (1 - k) * 18}%) scale(${0.82 + 0.18 * k})`,
opacity: Math.min(1, k * 1.6) }}>
<NameCard name={t.text} lines={t.lines} size={s} />
</div>
);
}
if (t.kind in CARDS) {
const Card = CARDS[t.kind as keyof typeof CARDS];
return (
<>
{t.panel && <PanelBackdrop k={k} />}
<div style={{ ...at(t.x, t.y), transform: `translate(-50%, -50%) translateY(${(1 - k) * 6}%) scale(${0.8 + 0.2 * k})`, opacity: Math.min(1, k * 1.6) }}>
<Card t={t} s={s} frame={frame} fps={fps} />
</div>
</>
);
}
const base = { ...at(t.x, t.y), transform: `translate(-50%, -50%) rotate(${t.rotate ?? 0}deg) scale(${0.4 + 0.6 * k})`, opacity: Math.min(1, k * 1.4) };
if (t.kind === "tag") return <div style={base}><TagLabel text={t.text} tone={t.tone} /></div>;
const sh = t.kind === "onomatopoeia" ? shake(frame, 4) : { x: 0, y: 0 };
const color = t.tone === "danger" ? COLORS.danger : t.kind === "big" ? "#ffffff" : COLORS.key; const color = t.tone === "danger" ? COLORS.danger : t.kind === "big" ? "#ffffff" : COLORS.key;
return ( return (
<div style={{ ...base, transform: `${base.transform} translate(${s.x}px, ${s.y}px)`, fontFamily: FONT_CAPTION, color, <div style={{ ...base, transform: `${base.transform} translate(${sh.x}px, ${sh.y}px)`, fontFamily: FONT_CAPTION, color,
fontSize: t.kind === "big" ? "12cqw" : "9cqw", whiteSpace: "nowrap", WebkitTextStroke: "0.35cqw #121326", fontSize: t.kind === "big" ? "12cqw" : "9cqw", whiteSpace: "nowrap", WebkitTextStroke: "0.35cqw #121326",
paintOrder: "stroke fill", textShadow: "0 0.6cqw 0 rgba(0,0,0,0.35)" }}> paintOrder: "stroke fill", textShadow: "0 0.6cqw 0 rgba(0,0,0,0.35)" }}>
{t.text.toUpperCase()} {t.text.toUpperCase()}
@@ -77,21 +327,61 @@ export function CrossOut({ k }: { k: number }) {
); );
} }
export function Hud({ hud, frame, fps }: { hud: NonNullable<ShotSpec["hud"]>; frame: number; fps: number }) { /** Hora do HUD andando: "10:06" + minutos por segundo de trecho. */
let clock = hud.clock; export function hudClock(clock: string | undefined, t: number, minutesPerSecond?: number): string | undefined {
if (clock && /^\d{1,2}:\d{2}$/.test(clock) && hud.clockMinutesPerSecond) { if (!clock || !/^\d{1,2}:\d{2}$/.test(clock) || !minutesPerSecond) return clock;
const [h, m] = clock.split(":").map(Number); const [h, m] = clock.split(":").map(Number);
const total = (h * 60 + m + Math.floor((frame / fps) * hud.clockMinutesPerSecond)) % (24 * 60); const total = (h * 60 + m + Math.floor(t * minutesPerSecond)) % (24 * 60);
clock = `${String(Math.floor(total / 60)).padStart(2, "0")}:${String(total % 60).padStart(2, "0")}`; return `${String(Math.floor(total / 60)).padStart(2, "0")}:${String(total % 60).padStart(2, "0")}`;
} }
/** Valor do HUD zerado ou negativo ("R$ 0,00", "-12") pede vermelho. */
export function hudValueTone(value: string, tone?: Tone): Tone | undefined {
if (tone) return tone;
const v = value.trim();
if (/^[^\d]*-/.test(v)) return "danger";
const digits = v.replace(/[^\d]/g, "");
return digits && Number(digits) === 0 ? "danger" : undefined;
}
/**
* Painel do topo (fixo, sem animação de entrada: continua igual de um trecho para o outro). Esquerda: bloco amarelo
* (`badge`) + hora com ponto vermelho sobre fundo escuro e, embaixo, faixa clara com o lugar. Direita, opcional:
* rótulo pequeno + valor grande e faixa amarela com a nota.
*/
export function Hud({ hud, frame, fps }: { hud: HudSpec; frame: number; fps: number }) {
const clock = hudClock(hud.clock, frame / fps, hud.clockMinutesPerSecond);
const place = hud.place ?? hud.label;
const row = u(8);
const big: React.CSSProperties = { fontFamily: FONT_CAPTION, fontSize: u(5.8), lineHeight: 1, whiteSpace: "nowrap", paddingTop: u(0.3) };
const strip: React.CSSProperties = { ...label(2.5, UI.ink, 0.07), height: u(4.2), display: "flex", alignItems: "center", padding: `0 ${u(2.2)}` };
const shadow = `0 ${u(0.55)} 0 rgba(6,8,18,0.6)`;
const tone = hud.value ? hudValueTone(hud.value, hud.valueTone) : undefined;
return ( return (
<div style={{ position: "absolute", top: "5.5%", left: 0, right: 0, display: "flex", justifyContent: "center", alignItems: "center", <>
gap: "1.4cqw", fontFamily: FONT_LABEL }}> <div style={{ position: "absolute", left: u(4), top: u(4.5), display: "inline-flex", flexDirection: "column", alignItems: "stretch", boxShadow: shadow }}>
<span style={{ background: COLORS.danger, color: "#fff", fontSize: "3.4cqw", padding: "0.2em 0.5em 0.1em", borderRadius: "0.25em" }}>⚡ {hud.badge.toUpperCase()}</span> <div style={{ display: "flex", height: row, background: clock ? "#11141f" : undefined }}>
<span style={{ color: "#fff", fontSize: "4.2cqw" }}>{hud.label.toUpperCase()}</span> <div style={{ ...big, background: UI.yellow, color: UI.ink, display: "flex", alignItems: "center", padding: `0 ${u(2.2)}` }}>{hud.badge.toUpperCase()}</div>
{clock && <span style={{ background: "#0d0f1f", color: COLORS.key, fontSize: "3.4cqw", padding: "0.2em 0.45em 0.1em", borderRadius: "0.25em", {clock && (
border: "0.25cqw solid #3a3f6b" }}>{clock}</span>} <div style={{ ...big, color: "#ffffff", display: "flex", alignItems: "center", gap: u(1.5), padding: `0 ${u(2.4)} 0 ${u(2.2)}` }}>
<span style={{ width: u(1.6), height: u(1.6), borderRadius: "50%", background: UI.red, marginTop: u(-0.3) }} />
{clock}
</div> </div>
)}
</div>
{place && <div style={{ ...strip, background: UI.cream }}>{place.toUpperCase()}</div>}
</div>
{hud.value && (
<div style={{ position: "absolute", right: u(4), top: u(4.5), display: "inline-flex", flexDirection: "column", alignItems: "flex-end" }}>
<div style={{ display: "flex", height: row, boxShadow: hud.note ? "none" : shadow }}>
{hud.valueLabel && <div style={{ ...label(2.5, UI.muted, 0.1), background: UI.cell, display: "flex", alignItems: "center", padding: `0 ${u(1.5)}` }}>{hud.valueLabel.toUpperCase()}</div>}
<div style={{ ...big, background: "#11141f", color: tone === "danger" ? UI.redSoft : tone ? TONE_TEXT[tone] : "#ffffff", display: "flex", alignItems: "center",
padding: `0 ${u(2.2)}` }}>{hud.value.toUpperCase()}</div>
</div>
{hud.note && <div style={{ ...strip, background: UI.yellow, boxShadow: shadow }}>{hud.note.toUpperCase()}</div>}
</div>
)}
</>
); );
} }
@@ -107,22 +397,29 @@ export function captionChunks(words: Word[]): Word[][] {
return chunks; return chunks;
} }
export function Captions({ words, frame, fps, y = 0.665 }: { words: Word[]; frame: number; fps: number; y?: number }) { /**
* Legenda: 2–3 palavras grandes em letra condensada branca, contorno e sombra escuros (deslocada para baixo e à
* esquerda, como a referência); palavra-chave maior e amarela, perigo vermelho.
*/
export function Captions({ words, frame, fps, y = 0.8 }: { words: Word[]; frame: number; fps: number; y?: number }) {
const t = frame / fps; const t = frame / fps;
const chunks = captionChunks(words); const chunks = captionChunks(words);
const chunk = chunks.find((c, i) => t >= c[0].startS && (i === chunks.length - 1 || t < chunks[i + 1][0].startS)); const chunk = chunks.find((c, i) => t >= c[0].startS && (i === chunks.length - 1 || t < chunks[i + 1][0].startS));
if (!chunk) return null; if (!chunk) return null;
const last = chunk[chunk.length - 1]; const last = chunk[chunk.length - 1];
if (t > last.endS + 0.6) return null; if (t > last.endS + 0.6) return null;
const ink = "#0f1226";
return ( return (
<div style={{ position: "absolute", left: "6%", right: "6%", top: `${y * 100}%`, transform: "translateY(-50%)", display: "flex", <div style={{ position: "absolute", left: "5%", right: "5%", top: `${y * 100}%`, transform: "translateY(-50%)", display: "flex",
flexWrap: "wrap", justifyContent: "center", alignItems: "baseline", columnGap: "2.2cqw", fontFamily: FONT_CAPTION, lineHeight: 1.05 }}> flexWrap: "wrap", justifyContent: "center", alignItems: "baseline", columnGap: u(2.4), fontFamily: FONT_CAPTION, lineHeight: 1.08 }}>
{chunk.filter((w) => t >= w.startS).map((w, i) => { {chunk.filter((w) => t >= w.startS).map((w, i) => {
const k = pop(frame, fps, w.startS, 320); const k = pop(frame, fps, w.startS, 320);
const color = w.tone === "danger" ? COLORS.danger : w.tone === "key" ? COLORS.key : "#ffffff"; const strong = w.tone === "key" || w.tone === "danger";
const color = w.tone === "danger" ? COLORS.danger : w.tone === "key" ? UI.yellow : "#ffffff";
return ( return (
<span key={i} style={{ fontSize: "8.4cqw", color, transform: `scale(${0.55 + 0.45 * k})`, display: "inline-block", <span key={i} style={{ fontSize: u(strong ? 12.2 : 9.6), color, transform: `scale(${0.55 + 0.45 * k})`, transformOrigin: "50% 80%", display: "inline-block",
textShadow: "0 0.5cqw 0 rgba(0,0,0,0.55), 0 0 1.4cqw rgba(0,0,0,0.5)" }}> WebkitTextStroke: `${u(strong ? 1.1 : 0.9)} ${ink}`, paintOrder: "stroke fill",
textShadow: `${u(-0.7)} ${u(0.9)} 0 ${ink}, ${u(-0.35)} ${u(0.45)} 0 ${ink}, 0 0 ${u(2)} rgba(0,0,0,0.35)` }}>
{w.text.toUpperCase().replace(/[.,;:]$/, "")} {w.text.toUpperCase().replace(/[.,;:]$/, "")}
</span> </span>
); );
@@ -130,3 +427,16 @@ export function Captions({ words, frame, fps, y = 0.665 }: { words: Word[]; fram
</div> </div>
); );
} }
/** Textura de papel/granulado por cima de tudo: tira a cara de "vetor de computador" (acabamento de ilustração). */
export function Grain({ opacity = 0.11, seed = 3 }: { opacity?: number; seed?: number }) {
return (
<svg width="100%" height="100%" style={{ position: "absolute", inset: 0, mixBlendMode: "overlay", opacity, pointerEvents: "none" }}>
<filter id={`grain${seed}`}>
<feTurbulence type="fractalNoise" baseFrequency="0.85" numOctaves={2} seed={seed} stitchTiles="stitch" />
<feColorMatrix type="saturate" values="0" />
</filter>
<rect width="100%" height="100%" filter={`url(#grain${seed})`} />
</svg>
);
}
+512 -92
View File
@@ -1,142 +1,562 @@
// Lugares montados por PEÇAS (não há cenário pronto): paleta + céu/hora + chão + peças posicionadas por // Lugares montados por PEÇAS (não há cenário pronto): paleta + céu/hora + chão + peças posicionadas por
// profundidade (z: 0 = frente, 1 = fundo). Parque de dia, cemitério na névoa, quarto à noite, bunker com foco // profundidade (z: 0 = frente, 1 = fundo). Parque de dia, cemitério na névoa, quarto à noite, bunker com foco
// de luz… tudo sai da mesma gramática. Espaço de desenho 1080×1920; chão começa em `horizon` (fração da altura). // de luz… tudo sai da mesma gramática. Espaço de desenho 1080×1920; chão começa em `horizon` (fração da altura).
//
// Regras de acabamento (valem para toda peça, ver elements/paint.ts): sombreado em 2 tons com a luz vindo da
// esquerda; 3 planos com perspectiva atmosférica (o fundo puxa para a cor do céu/parede, a frente escurece);
// sombra de contato no chão sob cada objeto. Tudo por mistura de cor — nada de blur por quadro.
import React from "react"; import React from "react";
import { rng } from "./random"; import { rng } from "./random";
import type { ShotSpec } from "./spec"; import type { ShotSpec } from "./spec";
import { makePaint, mix, palette, type Pal, type PaletteId } from "./elements/paint";
import { NATURE, type Draw } from "./elements/nature";
import { BUILT, FRONT_PART } from "./elements/built";
import { INDOOR } from "./elements/indoor";
export const PALETTES = ["night", "sepia", "day", "dusk", "gray"] as const; export { PALETTES, palette, type PaletteId } from "./elements/paint";
export type PaletteId = (typeof PALETTES)[number];
export const GROUNDS = ["grass", "street", "dirt", "floor", "sand", "water", "none"] as const; export const GROUNDS = ["grass", "street", "dirt", "floor", "sand", "water", "none"] as const;
export const ELEMENTS = ["tree", "deadtree", "pine", "bush", "rock", "mountain", "cloud", "bench", "lamp", "gravestone", "cross", "fence", export const ELEMENTS = ["tree", "deadtree", "pine", "bush", "rock", "mountain", "cloud", "bench", "lamp", "gravestone", "cross", "fence",
"house", "building", "car", "sign", "door", "window", "table", "bed", "shelf", "crate", "tent", "fire"] as const; "house", "building", "car", "sign", "door", "window", "table", "bed", "shelf", "crate", "tent", "fire",
"ark", "ark_frame", "scaffold", "planks", "rainbow", "waves", "palm", "outcrop",
"cabinet", "locker", "frame", "pendant", "desklamp", "desk", "clothesline", "wall", "facade", "shopfront"] as const;
/** Tempo por cima da cena (chuva caindo; tempestade = chuva forte + relâmpago + céu mais escuro). */
export const WEATHERS = ["none", "rain", "storm"] as const;
export type ElementKind = (typeof ELEMENTS)[number]; export type ElementKind = (typeof ELEMENTS)[number];
/** Fonte de luz posicionada (`spec.lightSource`): luminária, janela ou sol. */
export const LIGHT_SOURCES = ["lamp", "window", "sun"] as const;
export type Place = { export type Place = {
ground: (typeof GROUNDS)[number]; ground: (typeof GROUNDS)[number];
/** Interno: parede no lugar do céu (quarto, bunker, loja). */ /** Interno: parede no lugar do céu (quarto, bunker, loja). */
indoor?: boolean; indoor?: boolean;
/** Linha do horizonte (fração da altura; padrão 0,56). */ /** Linha do horizonte / pé da parede (fração da altura; padrão 0,56 fora e 0,62 dentro). */
horizon?: number; horizon?: number;
fog?: boolean; fog?: boolean;
elements: { kind: ElementKind; x: number; z?: number; scale?: number; flip?: boolean; color?: string }[]; weather?: (typeof WEATHERS)[number];
/** Água cobrindo o lugar: altura da superfície (fração da altura do quadro, 0 = topo) do início ao fim do trecho.
* Ex.: { from: 0.8, to: 0.5 } = a água sobe. O que não boia fica embaixo dela. */
flood?: { from: number; to: number };
elements: {
kind: ElementKind; x: number; z?: number; scale?: number; flip?: boolean; color?: string;
/** Sobe a peça (fração da altura do quadro): arca em cima do monte. */
lift?: number;
/** Boia na água (com `flood`, acompanha a superfície e balança). */
float?: boolean;
/** Tem gente DENTRO (arca, carro): a parte da frente da peça é desenhada por cima dos personagens. */
occupied?: boolean;
}[];
}; };
type Pal = { sky: [string, string]; wall: string; ground: Record<string, string>; far: string; near: string; ink: string; leaf: string; trunk: string; stone: string; light: string };
const P: Record<PaletteId, Pal> = {
night: { sky: ["#0b0e22", "#1c2147"], wall: "#2a2f4a", far: "#2a2d57", near: "#3b3f74", ink: "#0c0d1a", leaf: "#24445a", trunk: "#2b2338", stone: "#5a5f86", light: "#ffc94a",
ground: { grass: "#1d2e3a", street: "#1a1d38", dirt: "#2a2433", floor: "#22243a", sand: "#4a4560", water: "#152a4a" } },
sepia: { sky: ["#c9ad83", "#e8d6ae"], wall: "#7d6a55", far: "#a88f6e", near: "#6e5843", ink: "#2a2018", leaf: "#7b7a45", trunk: "#5a4330", stone: "#9b9387", light: "#ffd98a",
ground: { grass: "#8b8a52", street: "#6a5a4a", dirt: "#7a5a3c", floor: "#5e4c3c", sand: "#d2b886", water: "#6f8a8a" } },
day: { sky: ["#5aa9e6", "#cfeaf8"], wall: "#e9dcc5", far: "#9cc3d9", near: "#d98a5c", ink: "#22252e", leaf: "#4caf50", trunk: "#7a5232", stone: "#a9adb5", light: "#fff3b0",
ground: { grass: "#78c25a", street: "#8a8f99", dirt: "#b88a5a", floor: "#c9a77c", sand: "#f0d79a", water: "#3f9ad8" } },
dusk: { sky: ["#2a2c5c", "#e8946a"], wall: "#4a3a52", far: "#4c3f6e", near: "#6a4a62", ink: "#140f1c", leaf: "#2f4a3f", trunk: "#3a2a2a", stone: "#7a7090", light: "#ffcf7a",
ground: { grass: "#3a4a3a", street: "#3a3348", dirt: "#4a3530", floor: "#3c3040", sand: "#a87d6a", water: "#4a5a8a" } },
gray: { sky: ["#6f7680", "#b4b9bf"], wall: "#565b63", far: "#8a9098", near: "#5c6168", ink: "#1b1d21", leaf: "#5a6b55", trunk: "#4a4038", stone: "#9aa0a8", light: "#f2e6c8",
ground: { grass: "#5f6e55", street: "#4a4f57", dirt: "#5e5246", floor: "#45484f", sand: "#a8a08a", water: "#5a6f80" } },
};
export const palette = (id: PaletteId | undefined): Pal => P[id ?? "night"] ?? P.night;
const W = 1080; const W = 1080;
const H = 1920; const H = 1920;
const DRAW: Record<string, Draw> = { ...NATURE, ...BUILT, ...INDOOR };
function mix(a: string, b: string, k: number): string { /** Peças presas na parede do fundo quando o lugar é interno (o z delas é ignorado). */
const pa = parseInt(a.slice(1), 16); const WALL_MOUNTED = new Set<ElementKind>(["window", "frame", "door"]);
const pb = parseInt(b.slice(1), 16); /** Peças penduradas no teto: a origem é o topo do quadro. */
const ch = (s: number) => Math.round(((pa >> s) & 255) * (1 - k) + ((pb >> s) & 255) * k); const CEILING = new Set<ElementKind>(["pendant"]);
return `#${[16, 8, 0].map((s) => ch(s).toString(16).padStart(2, "0")).join("")}`; /** Objetos de mesa: sobem sozinhos para cima da mesa/escrivaninha mais próxima (se não tiver `lift`). */
const ON_TOP = new Set<ElementKind>(["desklamp"]);
/** Altura do tampo (unidades da peça) das superfícies que recebem objetos de mesa. */
const SURFACE_TOP: Partial<Record<ElementKind, number>> = { desk: 330, table: 304 };
/** Só as peças assimétricas espelham; nas simétricas o `flip` trocaria só o lado da sombra (a luz é sempre da esquerda). */
const FLIPPABLE = new Set<ElementKind>(["deadtree", "palm", "car", "bed", "desklamp", "waves", "clothesline", "outcrop"]);
/** Meia largura da base de cada peça (unidades da peça) para a sombra de contato; 0 = sem sombra. */
const FOOT: Partial<Record<ElementKind, number>> = {
tree: 130, deadtree: 90, pine: 190, bush: 220, rock: 130, bench: 270, lamp: 60, gravestone: 125, cross: 60, fence: 470,
house: 420, building: 280, car: 390, sign: 40, table: 290, bed: 400, shelf: 230, crate: 170, tent: 350, fire: 130,
ark: 380, ark_frame: 380, scaffold: 140, planks: 185, palm: 80, outcrop: 340, cabinet: 185, locker: 330, desk: 340,
wall: 730, facade: 560, shopfront: 460, desklamp: 90, clothesline: 0,
};
const isNight = (id: PaletteId | undefined) => (id ?? "night") === "night";
/** Zoom do fundo pelo enquadramento: em meio corpo/de perto a câmera está mais perto, o fundo cresce junto. */
function backgroundZoom(spec: ShotSpec): number {
const framings = (spec.actors ?? []).flatMap((a) => (a.kind === "person" && a.framing ? [a.framing] : []));
if (framings.includes("close")) return 1.32;
if (framings.includes("medium")) return 1.16;
return 1;
} }
/** Uma peça desenhada com a base em (0,0), altura de referência ~300 px. */ type El = Place["elements"][number] & { i: number; z: number };
function Element({ kind, pal, color, seed }: { kind: ElementKind; pal: Pal; color?: string; seed: number }) { type Placed = { e: El; x: number; y: number; s: number; zEff: number; flip: boolean };
const r = rng(seed); type Layout = { horizon: number; indoor: boolean; zoom: number; items: Placed[] };
switch (kind) {
case "tree": return <g><rect x={-14} y={-150} width={28} height={150} fill={pal.trunk} /><circle cx={0} cy={-210} r={95} fill={color ?? pal.leaf} /><circle cx={-60} cy={-170} r={60} fill={color ?? pal.leaf} /><circle cx={62} cy={-175} r={62} fill={color ?? pal.leaf} /></g>; /** Onde cada peça fica (base, escala, profundidade efetiva). A camada de luz usa a mesma conta. */
case "pine": return <g><rect x={-12} y={-60} width={24} height={60} fill={pal.trunk} /><polygon points="0,-330 -90,-60 90,-60" fill={color ?? pal.leaf} /></g>; export function layoutPlace(spec: ShotSpec): Layout {
case "deadtree": return <g stroke={color ?? pal.trunk} strokeLinecap="round" fill="none"><path d="M0 0 L0 -220" strokeWidth={26} /><path d="M0 -120 L-70 -200 M-40 -160 L-80 -150 M0 -170 L60 -250 M30 -210 L80 -215 M0 -220 L-20 -280" strokeWidth={12} /></g>; const place = spec.place!;
case "bush": return <g fill={color ?? pal.leaf}><circle cx={-40} cy={-35} r={42} /><circle cx={10} cy={-50} r={52} /><circle cx={55} cy={-30} r={38} /></g>; const indoor = !!place.indoor;
case "rock": return <path d="M-70 0 Q-80 -50 -30 -70 Q20 -90 60 -50 Q85 -20 70 0 Z" fill={color ?? pal.stone} />; const horizon = (place.horizon ?? (indoor ? 0.62 : 0.56)) * H;
case "mountain": return <g><polygon points="-520,0 0,-520 520,0" fill={color ?? pal.far} /><polygon points="-110,-410 0,-520 110,-410 50,-430 0,-400 -50,-430" fill="#ffffff" opacity={0.6} /></g>; const near = indoor ? H * 0.8 : H * 0.72;
case "cloud": return <g fill={color ?? "#ffffff"} opacity={0.85}><ellipse cx={0} cy={-40} rx={110} ry={40} /><circle cx={-40} cy={-70} r={45} /><circle cx={30} cy={-80} r={55} /></g>; const items: Placed[] = place.elements.map((raw, i) => {
case "bench": return <g fill={color ?? "#8a5a3a"}><rect x={-110} y={-70} width={220} height={16} rx={4} /><rect x={-110} y={-120} width={220} height={14} rx={4} /><rect x={-95} y={-70} width={12} height={70} fill={pal.ink} /><rect x={83} y={-70} width={12} height={70} fill={pal.ink} /></g>; const e: El = { ...raw, i, z: raw.z ?? 0.3 };
case "lamp": return <g><rect x={-7} y={-420} width={14} height={420} fill={pal.ink} /><rect x={-36} y={-440} width={72} height={26} rx={8} fill={pal.ink} /><ellipse cx={0} cy={-408} rx={26} ry={8} fill={pal.light} /><path d="M-24 -408 L-140 0 L140 0 L24 -408 Z" fill={pal.light} opacity={0.08} /></g>; const wall = indoor && WALL_MOUNTED.has(e.kind);
case "gravestone": return <g><path d="M-55 0 L-55 -130 Q-55 -185 0 -185 Q55 -185 55 -130 L55 0 Z" fill={color ?? pal.stone} /><rect x={-28} y={-120} width={56} height={6} rx={3} fill={pal.ink} opacity={0.35} /><rect x={-22} y={-100} width={44} height={6} rx={3} fill={pal.ink} opacity={0.35} /></g>; const zEff = wall ? 1 : e.z;
case "cross": return <g fill={color ?? pal.stone}><rect x={-12} y={-200} width={24} height={200} /><rect x={-60} y={-160} width={120} height={22} /></g>; const depth = 1 - zEff * (indoor ? 0.35 : 0.62);
case "fence": return <g fill={color ?? pal.ink}>{Array.from({ length: 9 }, (_, i) => <rect key={i} x={-200 + i * 50} y={-130} width={14} height={130} />)}<rect x={-210} y={-110} width={430} height={10} /><rect x={-210} y={-50} width={430} height={10} /></g>; const s = (e.scale ?? 1) * depth * 1.15;
case "house": return <g><polygon points="-150,-180 0,-290 150,-180" fill={pal.ink} opacity={0.6} /><rect x={-140} y={-180} width={280} height={180} fill={color ?? pal.near} /><rect x={-110} y={-140} width={50} height={50} rx={4} fill={pal.light} opacity={r() > 0.5 ? 1 : 0.15} /><rect x={60} y={-140} width={50} height={50} rx={4} fill={pal.light} opacity={r() > 0.5 ? 1 : 0.15} /><rect x={-25} y={-100} width={50} height={100} fill={pal.ink} opacity={0.7} /></g>; let y: number;
case "building": { if (CEILING.has(e.kind)) y = 0;
const floors = 4 + Math.floor(r() * 4); else if (e.kind === "cloud") y = horizon * (0.15 + 0.5 * e.z);
return <g><rect x={-120} y={-floors * 80} width={240} height={floors * 80} fill={color ?? pal.far} />{Array.from({ length: floors * 3 }, (_, i) => <rect key={i} x={-95 + (i % 3) * 70} y={-floors * 80 + 20 + Math.floor(i / 3) * 80} width={44} height={40} fill={pal.light} opacity={r() > 0.7 ? 0.9 : 0.12} />)}</g>; else y = horizon + (1 - zEff) * (near - horizon);
y -= (e.lift ?? 0) * H;
return { e, x: e.x * W, y, s, zEff, flip: !!e.flip && FLIPPABLE.has(e.kind) };
});
// Objeto de mesa perto de uma mesa (mesma profundidade, dentro do tampo) vai para cima dela.
for (const it of items) {
if (!ON_TOP.has(it.e.kind) || it.e.lift !== undefined) continue;
const surface = items.find((o) => SURFACE_TOP[o.e.kind] && Math.abs(o.e.z - it.e.z) <= 0.25 && Math.abs(o.x - it.x) < (FOOT[o.e.kind] ?? 0) * o.s);
if (!surface) continue;
it.y = surface.y - SURFACE_TOP[surface.e.kind]! * surface.s;
it.s = surface.s * (it.e.scale ?? 1) * 0.9;
it.zEff = surface.zEff - 0.001;
} }
case "car": return <g><path d="M-150 -40 L-150 -90 Q-140 -110 -100 -112 L-60 -160 L70 -160 L110 -112 L150 -100 L150 -40 Z" fill={color ?? "#c8443a"} /><rect x={-50} y={-150} width={50} height={36} fill="#cfe3f3" opacity={0.85} /><rect x={8} y={-150} width={52} height={36} fill="#cfe3f3" opacity={0.85} /><circle cx={-90} cy={-35} r={32} fill={pal.ink} /><circle cx={95} cy={-35} r={32} fill={pal.ink} /></g>; items.sort((a, b) => b.zEff - a.zEff || a.e.i - b.e.i);
case "sign": return <g><rect x={-6} y={-220} width={12} height={220} fill={pal.ink} /><rect x={-90} y={-260} width={180} height={70} rx={8} fill={color ?? "#2f6d3a"} stroke="#ffffff" strokeWidth={5} /></g>; return { horizon, indoor, zoom: backgroundZoom(spec), items };
case "door": return <g><rect x={-80} y={-330} width={160} height={330} rx={4} fill={color ?? "#4a2f22"} /><rect x={-60} y={-305} width={120} height={130} rx={3} fill="#000000" opacity={0.15} /><rect x={-60} y={-155} width={120} height={130} rx={3} fill="#000000" opacity={0.15} /><circle cx={52} cy={-165} r={9} fill="#e6c27a" /></g>; }
case "window": return <g><rect x={-120} y={-260} width={240} height={200} rx={6} fill={pal.ink} /><rect x={-108} y={-248} width={216} height={176} fill={color ?? mix(pal.sky[0], pal.sky[1], 0.5)} /><rect x={-4} y={-248} width={8} height={176} fill={pal.ink} /><rect x={-108} y={-164} width={216} height={8} fill={pal.ink} /></g>;
case "table": return <g fill={color ?? "#7a5232"}><rect x={-140} y={-130} width={280} height={20} rx={4} /><rect x={-120} y={-110} width={18} height={110} /><rect x={102} y={-110} width={18} height={110} /></g>; /** Sol/lua no céu (sempre do lado esquerdo: é de lá que vem a luz das peças). */
case "bed": return <g><rect x={-170} y={-90} width={340} height={60} rx={10} fill={color ?? "#5a6aa8"} /><rect x={-170} y={-150} width={24} height={150} fill={pal.trunk} /><rect x={-140} y={-120} width={90} height={34} rx={12} fill="#eeeeee" /><rect x={146} y={-110} width={24} height={110} fill={pal.trunk} /></g>; export function sunOf(id: PaletteId | undefined, horizon: number): { x: number; y: number; r: number } | null {
case "shelf": return <g><rect x={-120} y={-360} width={240} height={360} fill={color ?? pal.trunk} />{[0, 1, 2, 3].map((i) => <g key={i}><rect x={-108} y={-340 + i * 88} width={216} height={70} fill="#000000" opacity={0.25} />{[0, 1, 2, 3, 4].map((j) => <rect key={j} x={-100 + j * 42} y={-330 + i * 88 + (r() * 14)} width={30} height={56 - (r() * 14)} rx={3} fill={["#e8463d", "#f2c230", "#4fb0e8", "#5cc48a", "#e8e8ee"][(i + j) % 5]} />)}</g>)}</g>; switch (id ?? "night") {
case "crate": return <g><rect x={-70} y={-140} width={140} height={140} fill={color ?? "#a0743f"} /><path d="M-70 -140 L70 0 M70 -140 L-70 0" stroke="#6e4e28" strokeWidth={10} /><rect x={-70} y={-140} width={140} height={140} fill="none" stroke="#6e4e28" strokeWidth={10} /></g>; case "day": return { x: W * 0.2, y: H * 0.2, r: 66 };
case "tent": return <g><polygon points="-170,0 0,-220 170,0" fill={color ?? "#d9773a"} /><polygon points="-40,0 0,-120 40,0" fill={pal.ink} opacity={0.6} /></g>; case "sepia": return { x: W * 0.2, y: H * 0.19, r: 70 };
case "fire": return <g><rect x={-60} y={-18} width={120} height={18} rx={6} fill={pal.trunk} /><path d="M-40 -18 Q-50 -80 -10 -120 Q-5 -80 20 -70 Q30 -110 10 -150 Q70 -100 45 -18 Z" fill="#ff8a2a" /><path d="M-15 -18 Q-20 -60 5 -80 Q10 -50 25 -45 Q30 -30 20 -18 Z" fill="#ffd34a" /></g>; case "dusk": return { x: W * 0.2, y: horizon - H * 0.13, r: 96 };
case "night": return { x: W * 0.22, y: H * 0.15, r: 44 };
default: return null; default: return null;
} }
} }
export function PlaceBackground({ spec, frame }: { spec: ShotSpec; frame: number }) { /** Altura da superfície da água no instante (fração da altura; null = sem enchente). */
export function floodLevel(place: Place | undefined, progress: number): number | null {
if (!place?.flood) return null;
const p = Math.max(0, Math.min(1, progress));
const k = p < 0.5 ? 2 * p * p : 1 - (-2 * p + 2) ** 2 / 2;
return place.flood.from + (place.flood.to - place.flood.from) * k;
}
/** Uma peça no lugar: sombra de contato + desenho com a tinta da profundidade dela. */
function PlacedElement({ it, pal, spec, hazeColor, y, rot = 0, part }: { it: Placed; pal: Pal; spec: ShotSpec; hazeColor: string; y?: number; rot?: number; part?: "front" }) {
const { e } = it;
const place = spec.place!;
const indoor = !!place.indoor;
const z = it.zEff;
const sky = e.kind === "cloud" || e.kind === "rainbow";
const haze = sky ? 0.12 : indoor ? z * 0.22 : Math.min(0.85, Math.pow(z, 1.8) * 0.66 + (place.fog ? 0.04 + z * 0.16 : 0));
const front = !sky && z < 0.25 ? (0.25 - z) * 0.5 : 0;
const p = makePaint(pal, rng(spec.seed + e.i * 17), { haze, hazeColor, front, indoor, night: isNight(spec.palette) });
const draw = part === "front" ? FRONT_PART[e.kind] : DRAW[e.kind];
if (!draw) return null;
const foot = (CEILING.has(e.kind) || (indoor && WALL_MOUNTED.has(e.kind)) || e.float || (e.lift ?? 0) > 0.02) ? 0 : FOOT[e.kind] ?? 0;
const s = it.s;
return (
<g transform={`translate(${it.x} ${y ?? it.y}) rotate(${rot}) scale(${it.flip ? -s : s} ${s})`}>
{foot > 0 && part !== "front" && <ellipse cx={foot * 0.1} cy={4} rx={foot * 1.12} ry={Math.min(46, Math.max(16, foot * 0.11))} fill="url(#cShadow)" opacity={1 - z * 0.5} />}
{draw(p, e.color)}
</g>
);
}
/** Céu com degradê rico, sol/lua com halo (ou parede do interior). Não muda com o quadro. */
function SkyLayer({ spec, horizon }: { spec: ShotSpec; horizon: number }) {
const pal = palette(spec.palette);
const place = spec.place!;
if (place.indoor) {
const wallTop = mix(pal.wall, pal.ink, 0.42);
return <g>
<defs>
<linearGradient id="placeWall" x1="0" y1="0" x2="0" y2="1">
<stop offset="0" stopColor={wallTop} /><stop offset="0.45" stopColor={mix(pal.wall, pal.ink, 0.12)} /><stop offset="1" stopColor={pal.wall} />
</linearGradient>
<linearGradient id="placeCorner" x1="0" y1="0" x2="1" y2="0">
<stop offset="0" stopColor={pal.shade} stopOpacity={0.4} /><stop offset="0.16" stopColor={pal.shade} stopOpacity={0} />
<stop offset="0.84" stopColor={pal.shade} stopOpacity={0} /><stop offset="1" stopColor={pal.shade} stopOpacity={0.45} />
</linearGradient>
</defs>
<rect width={W} height={H} fill="url(#placeWall)" />
</g>;
}
const sun = sunOf(spec.palette, horizon);
const night = isNight(spec.palette);
return <g>
<defs>
<linearGradient id="placeSky" gradientUnits="userSpaceOnUse" x1="0" y1="0" x2="0" y2={horizon}>
<stop offset="0" stopColor={pal.sky[0]} /><stop offset="0.55" stopColor={pal.sky[1]} /><stop offset="1" stopColor={pal.sky[2]} />
</linearGradient>
{sun && <radialGradient id="placeHalo" gradientUnits="userSpaceOnUse" cx={sun.x} cy={sun.y} r={sun.r * 4.2}>
<stop offset="0" stopColor={pal.halo} stopOpacity={night ? 0.35 : 0.75} /><stop offset="0.35" stopColor={pal.halo} stopOpacity={night ? 0.12 : 0.3} />
<stop offset="1" stopColor={pal.halo} stopOpacity={0} />
</radialGradient>}
</defs>
<rect width={W} height={H} fill="url(#placeSky)" />
{sun && <>
<circle cx={sun.x} cy={sun.y} r={sun.r * 4.2} fill="url(#placeHalo)" />
<circle cx={sun.x} cy={sun.y} r={sun.r} fill={pal.sun} />
{night
? <><circle cx={sun.x + 12} cy={sun.y - 8} r={9} fill={mix(pal.sun, "#b0a890", 0.4)} /><circle cx={sun.x - 14} cy={sun.y + 12} r={6} fill={mix(pal.sun, "#b0a890", 0.4)} /></>
: <circle cx={sun.x - sun.r * 0.25} cy={sun.y - sun.r * 0.25} r={sun.r * 0.55} fill="#ffffff" opacity={0.35} />}
</>}
</g>;
}
/** Chão (degradê + textura) e, ao fundo, a silhueta distante (morros ou cidade). */
function GroundLayer({ spec, horizon, hazeColor }: { spec: ShotSpec; horizon: number; hazeColor: string }) {
const place = spec.place!; const place = spec.place!;
const pal = palette(spec.palette); const pal = palette(spec.palette);
const horizon = (place.horizon ?? 0.56) * H; const rand = rng(spec.seed + 29);
const out: React.ReactNode[] = [];
const g = place.ground === "none" ? null : pal.ground[place.ground];
const span = H - horizon;
if (place.indoor) {
// Parede: lambri (meia-parede) ou listras, conforme a semente; rodapé no pé da parede.
const wall = pal.wall;
if (spec.seed % 2 === 0) {
const top = horizon - H * 0.17;
out.push(<rect key="dado" x={0} y={top} width={W} height={horizon - top} fill={mix(wall, pal.ink, 0.16)} />);
out.push(<path key="dadoP" d={Array.from({ length: 8 }, (_, i) => `M${i * 150 + 40} ${top + 30} L${i * 150 + 40} ${horizon - 40} L${i * 150 + 150} ${horizon - 40}`).join(" ")}
stroke={mix(wall, pal.ink, 0.3)} strokeWidth={6} fill="none" />);
out.push(<rect key="rail" x={0} y={top - 16} width={W} height={18} fill={mix(wall, pal.light, 0.22)} />);
out.push(<rect key="railS" x={0} y={top + 2} width={W} height={6} fill={mix(wall, pal.ink, 0.35)} />);
} else {
out.push(<path key="stripes" d={Array.from({ length: 12 }, (_, i) => `M${i * 96 + 30} 0 L${i * 96 + 30} ${horizon}`).join(" ")} stroke={mix(wall, pal.ink, 0.1)} strokeWidth={26} />);
}
out.push(<rect key="corner" x={0} y={0} width={W} height={horizon} fill="url(#placeCorner)" />);
} else if (place.ground === "grass" || place.ground === "dirt" || place.ground === "sand") {
// Morros distantes em 2 camadas, bem apagados (plano de fundo).
const ridge = (h: number, amp: number, seed: number) => {
const r = rng(seed);
let d = `M0 ${horizon + 2} L0 ${horizon - h}`;
for (let x = 0; x <= W + 180; x += 180) d += ` Q${x + 90} ${horizon - h - amp * (0.4 + r())} ${x + 180} ${horizon - h + (r() - 0.5) * amp * 0.5}`;
return d + ` L${W} ${horizon + 2} Z`;
};
out.push(<path key="r1" d={ridge(H * 0.075, H * 0.05, spec.seed + 3)} fill={mix(pal.far, hazeColor, 0.55)} />);
out.push(<path key="r2" d={ridge(H * 0.03, H * 0.03, spec.seed + 7)} fill={mix(g ?? pal.far, hazeColor, 0.45)} />);
} else if (place.ground === "street") {
// Cidade ao longe: blocos apagados com algumas janelas.
let x = -20;
const blocks: React.ReactNode[] = [];
while (x < W) {
const w = 90 + rand() * 120;
const h = H * (0.05 + rand() * 0.09);
blocks.push(<rect key={x} x={x} y={horizon - h} width={w} height={h + 2} fill={mix(pal.far, hazeColor, 0.5 + rand() * 0.15)} />);
x += w - 6;
}
out.push(<g key="city">{blocks}</g>);
}
if (g) {
out.push(<rect key="ground" x={0} y={horizon} width={W} height={span} fill="url(#placeGround)" />);
if (place.ground === "floor") {
// Tábuas em perspectiva: linhas que fogem para o ponto de fuga, juntas desencontradas, tom alternado.
const vpY = horizon - H * 0.3;
const k = (H - vpY) / (horizon - vpY);
const at = (xh: number, y: number) => W / 2 + (xh - W / 2) * ((y - vpY) / (horizon - vpY));
const n = 16;
const step = W / 9;
let seams = "";
for (let i = -n; i <= n; i++) {
const xh = W / 2 + i * step * 0.5;
if (Math.abs(i) % 2 === 1) {
const x2 = W / 2 + (i + 1) * step * 0.5;
out.push(<polygon key={`pl${i}`} points={`${xh},${horizon} ${x2},${horizon} ${W / 2 + (x2 - W / 2) * k},${H} ${W / 2 + (xh - W / 2) * k},${H}`} fill={mix(g, pal.ink, 0.06)} />);
}
seams += `M${xh} ${horizon} L${W / 2 + (xh - W / 2) * k} ${H} `;
for (let j = 0; j < 3; j++) {
const y = horizon + span * Math.pow(rand(), 1.4);
const xa = at(xh, y);
const xb = at(xh + step * 0.5, y);
seams += `M${xa} ${y} L${xb} ${y} `;
}
}
out.push(<path key="seams" d={seams} stroke={mix(g, pal.ink, 0.32)} strokeWidth={4} fill="none" />);
out.push(<rect key="base" x={0} y={horizon - 34} width={W} height={36} fill={mix(pal.wall, pal.ink, 0.38)} />);
out.push(<rect key="baseT" x={0} y={horizon - 34} width={W} height={7} fill={mix(pal.wall, pal.light, 0.15)} />);
out.push(<rect key="ao" x={0} y={horizon} width={W} height={26} fill={pal.ink} opacity={0.18} />);
} else if (place.ground === "street") {
const walk = horizon + span * 0.16;
const walkC = mix(mix("#d2c8b4", g, 0.3), hazeColor, 0.15);
out.push(<rect key="walk" x={0} y={horizon} width={W} height={walk - horizon} fill={walkC} />);
out.push(<path key="tiles" d={Array.from({ length: 14 }, (_, i) => { const x = -120 + i * 110; return `M${x} ${horizon} L${W / 2 + (x - W / 2) * 1.25} ${walk}`; }).join(" ") + ` M0 ${(horizon + walk) / 2} L${W} ${(horizon + walk) / 2}`}
stroke={mix(walkC, pal.ink, 0.18)} strokeWidth={3} fill="none" />);
out.push(<rect key="curb" x={0} y={walk} width={W} height={18} fill={mix(walkC, pal.light, 0.25)} />);
out.push(<rect key="curbS" x={0} y={walk + 18} width={W} height={20} fill={mix(g, pal.ink, 0.35)} />);
const lane = walk + (H - walk) * 0.42;
out.push(<path key="lane" d={Array.from({ length: 7 }, (_, i) => `M${i * 190 - 60} ${lane} l120 0`).join(" ")} stroke="#f2ecd8" strokeWidth={12} opacity={0.55} />);
} else if (place.ground === "grass" || place.ground === "dirt" || place.ground === "sand") {
// Faixas na perspectiva + tufos/pedrinhas/ondulações, maiores perto da câmera.
for (let b = 1; b < 6; b++) {
const y0 = horizon + span * Math.pow(b / 6, 1.7);
const y1 = horizon + span * Math.pow((b + 0.45) / 6, 1.7);
out.push(<rect key={`band${b}`} x={0} y={y0} width={W} height={y1 - y0} fill={b % 2 ? mix(g, pal.light, 0.06) : mix(g, pal.ink, 0.05)} opacity={0.45} />);
}
let marks = "";
for (let i = 0; i < 46; i++) {
const t = Math.pow(rand(), 0.8);
const y = horizon + span * t;
const x = rand() * W;
const s = 6 + t * 26;
if (place.ground === "grass") marks += `M${x - s} ${y} L${x - s * 0.3} ${y - s * 1.4} L${x} ${y} L${x + s * 0.4} ${y - s * 1.6} L${x + s} ${y} `;
else if (place.ground === "sand") marks += `M${x - s * 3} ${y} Q${x} ${y - s * 0.6} ${x + s * 3} ${y} `;
else marks += `M${x - s * 0.6} ${y} a${s * 0.6} ${s * 0.28} 0 1 0 ${s * 1.2} 0 a${s * 0.6} ${s * 0.28} 0 1 0 ${-s * 1.2} 0 `;
}
out.push(<path key="marks" d={marks} fill={place.ground === "dirt" ? mix(g, pal.ink, 0.14) : "none"}
stroke={place.ground === "grass" ? mix(g, pal.ink, 0.25) : place.ground === "sand" ? mix(g, pal.light, 0.35) : "none"} strokeWidth={place.ground === "sand" ? 5 : 4} strokeLinejoin="round" />);
}
}
return <g>{out}</g>;
}
export function PlaceBackground({ spec, frame, progress = 0 }: { spec: ShotSpec; frame: number; progress?: number }) {
const place = spec.place!;
const pal = palette(spec.palette);
const layout = React.useMemo(() => layoutPlace(spec), [spec]);
const { horizon, zoom } = layout;
const hazeColor = place.indoor ? pal.wall : mix(mix(pal.sky[2], pal.sky[1], 0.25), "#c8ccd6", place.fog ? 0.45 : 0);
const level = floodLevel(place, progress);
const waterY = level === null ? null : level * H;
const storm = place.weather === "storm";
const ground = place.ground === "none" ? null : pal.ground[place.ground]; const ground = place.ground === "none" ? null : pal.ground[place.ground];
const elements = [...place.elements].map((e, i) => ({ ...e, i, z: e.z ?? 0.3 })).sort((a, b) => b.z - a.z); // Tudo que não muda com o quadro é desenhado uma vez só (céu, chão, peças paradas).
const sky = React.useMemo(() => <SkyLayer spec={spec} horizon={horizon} />, [spec, horizon]);
const floating = (it: Placed) => !!it.e.float && waterY !== null;
const staticBack = React.useMemo(() => (
<g>
<GroundLayer spec={spec} horizon={horizon} hazeColor={hazeColor} />
{layout.items.filter((it) => !(it.e.float && place.flood)).map((it) => <PlacedElement key={it.e.i} it={it} pal={pal} spec={spec} hazeColor={hazeColor} />)}
</g>
), [spec, layout]); // eslint-disable-line react-hooks/exhaustive-deps
const rand = rng(spec.seed + 13); const rand = rng(spec.seed + 13);
const stars = !place.indoor && (spec.palette ?? "night") === "night" const stars = !place.indoor && isNight(spec.palette)
? Array.from({ length: 60 }, () => ({ x: rand() * W, y: rand() * horizon * 0.8, r: 1 + rand() * 2, p: rand() * 6 })) : []; ? Array.from({ length: 60 }, () => ({ x: rand() * W, y: rand() * horizon * 0.8, r: 1 + rand() * 2, p: rand() * 6 })) : [];
const zoomT = zoom === 1 ? undefined : `translate(${W / 2} ${horizon}) scale(${zoom}) translate(${-W / 2} ${-horizon})`;
return ( return (
<svg viewBox={`0 0 ${W} ${H}`} width="100%" height="100%" preserveAspectRatio="xMidYMid slice"> <svg viewBox={`0 0 ${W} ${H}`} width="100%" height="100%" preserveAspectRatio="xMidYMid slice">
<defs> <defs>
<linearGradient id="placeSky" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stopColor={pal.sky[0]} /><stop offset="1" stopColor={pal.sky[1]} /></linearGradient> <linearGradient id="placeFog" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stopColor="#ffffff" stopOpacity={0} />
<linearGradient id="placeFog" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stopColor="#ffffff" stopOpacity={0} /><stop offset="1" stopColor="#d8dce6" stopOpacity={0.35} /></linearGradient> <stop offset="0.3" stopColor="#d8dce6" stopOpacity={0.3} /><stop offset="1" stopColor="#d8dce6" stopOpacity={0.06} /></linearGradient>
<radialGradient id="cShadow"><stop offset="0" stopColor={pal.ink} stopOpacity={0.5} /><stop offset="0.6" stopColor={pal.ink} stopOpacity={0.28} /><stop offset="1" stopColor={pal.ink} stopOpacity={0} /></radialGradient>
{ground && <linearGradient id="placeGround" x1="0" y1="0" x2="0" y2="1">
{place.indoor
? <><stop offset="0" stopColor={mix(ground, pal.ink, 0.3)} /><stop offset="0.18" stopColor={ground} /><stop offset="1" stopColor={mix(ground, pal.ink, 0.32)} /></>
: <><stop offset="0" stopColor={mix(ground, hazeColor, 0.35)} /><stop offset="0.3" stopColor={ground} /><stop offset="1" stopColor={mix(ground, pal.ink, 0.22)} /></>}
</linearGradient>}
<linearGradient id="placeWater" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stopColor={mix(pal.ground.water, "#ffffff", 0.12)} /><stop offset="1" stopColor={mix(pal.ground.water, pal.ink, 0.35)} /></linearGradient>
</defs> </defs>
<rect width={W} height={H} fill={place.indoor ? pal.wall : "url(#placeSky)"} /> {sky}
{stars.map((s, i) => <circle key={i} cx={s.x} cy={s.y} r={s.r} fill="#fff" opacity={0.3 + 0.3 * Math.sin(frame / 12 + s.p)} />)} {stars.map((s, i) => <circle key={i} cx={s.x} cy={s.y} r={s.r} fill="#fff" opacity={0.3 + 0.3 * Math.sin(frame / 12 + s.p)} />)}
{!place.indoor && (spec.palette ?? "night") === "night" && <circle cx={W * 0.78} cy={H * 0.12} r={40} fill="#f4ecc8" />} <g transform={zoomT}>
{!place.indoor && (spec.palette === "day" || spec.palette === "sepia") && <circle cx={W * 0.8} cy={H * 0.1} r={60} fill={pal.light} opacity={0.9} />} {staticBack}
{place.indoor && <rect x={0} y={horizon - 18} width={W} height={18} fill={pal.ink} opacity={0.25} />} {waterY !== null && (
{ground && <rect x={0} y={horizon} width={W} height={H - horizon} fill={ground} />} <g>
{place.ground === "street" && Array.from({ length: 8 }, (_, i) => <rect key={i} x={i * 150 - 40} y={horizon + (H - horizon) * 0.32} width={90} height={9} rx={4} fill="#ffffff" opacity={0.25} />)} <rect x={0} y={waterY} width={W} height={H - waterY} fill="url(#placeWater)" />
{elements.map((e) => { <path d={`M0 ${waterY} ${Array.from({ length: 10 }, (_, i) => `Q${i * 108 + 54} ${waterY - 22 + Math.sin(frame / 9 + i) * 8} ${(i + 1) * 108} ${waterY}`).join(" ")}`}
// Profundidade: mais ao fundo = mais perto do horizonte, menor e mais apagado (névoa/atmosfera). stroke="#ffffff" strokeWidth={7} fill="none" opacity={0.55} />
const baseY = e.kind === "cloud" ? horizon * (0.15 + 0.5 * e.z) : horizon + (1 - e.z) * (H * 0.72 - horizon);
const scale = (e.scale ?? 1) * (1 - e.z * 0.62) * 1.15;
const fade = e.kind === "cloud" ? 0 : e.z * (place.fog ? 0.7 : 0.35);
return (
<g key={e.i} transform={`translate(${e.x * W} ${baseY}) scale(${e.flip ? -scale : scale} ${scale})`} opacity={1 - fade * 0.3}>
<Element kind={e.kind} pal={pal} color={e.color ?? (fade > 0.05 && e.kind !== "fire" ? undefined : undefined)} seed={spec.seed + e.i * 17} />
</g> </g>
); )}
})} {place.ground === "water" && waterY === null && Array.from({ length: 6 }, (_, i) => (
{place.fog && <rect x={0} y={horizon - H * 0.15} width={W} height={H * 0.5} fill="url(#placeFog)" />} <path key={`w${i}`} d={`M${((i * 197 + frame * 2) % (W + 200)) - 100} ${horizon + 60 + i * ((H - horizon) / 6)} q30 -16 60 0 q30 16 60 0`} stroke="#ffffff" strokeWidth={5} fill="none" opacity={0.35} />
))}
{layout.items.filter(floating).map((it) => (
// Boia: a quilha fica um pouco abaixo da superfície e a peça balança com a água.
<PlacedElement key={it.e.i} it={it} pal={pal} spec={spec} hazeColor={hazeColor}
y={waterY! + H * 0.035 + Math.sin(frame / 14 + it.e.i) * 9} rot={Math.sin(frame / 22 + it.e.i) * (storm ? 3.5 : 1.6)} />
))}
{waterY !== null && <rect x={0} y={waterY + H * 0.03} width={W} height={H} fill={pal.ground.water} opacity={0.35} />}
</g>
{place.fog && <rect x={0} y={horizon - H * 0.18} width={W} height={H - horizon + H * 0.18} fill="url(#placeFog)" />}
</svg> </svg>
); );
} }
/** Foco de luz vindo do teto (bunker, interrogatório) ou vinheta de anoitecer, por cima de tudo. */ type LightSpot = { kind: "lamp" | "window" | "sun" | "glow"; x: number; y: number; w?: number; h?: number; spread?: number; fixture?: boolean };
export function LightLayer({ light, palette: id }: { light: ShotSpec["light"]; palette?: PaletteId }) {
if (!light || light === "none") return null; /** Fonte de luz do trecho: a escolhida no spec, ou deduzida das peças (luminária > janela > sol). */
const pal = palette(id); export function resolveLight(spec: ShotSpec | undefined, light: ShotSpec["light"]): LightSpot | null {
if (light === "vignette") { if (light === "none") return null;
return <div style={{ position: "absolute", inset: 0, background: "radial-gradient(ellipse at 50% 45%, rgba(0,0,0,0) 45%, rgba(0,0,0,0.55) 100%)" }} />; const src = spec?.lightSource;
if (src) {
const dy = src.kind === "lamp" ? 0.2 : src.kind === "window" ? 0.32 : 0.2;
return { kind: src.kind, x: src.x * W, y: (src.y ?? dy) * H, w: W * 0.3, h: H * 0.18 };
}
const place = spec?.scene.kind === "place" ? spec.place : undefined;
const layout = place ? layoutPlace(spec!) : null;
const toScreen = (x: number, y: number) => layout && layout.zoom !== 1
? { x: W / 2 + (x - W / 2) * layout.zoom, y: layout.horizon + (y - layout.horizon) * layout.zoom } : { x, y };
const pendant = layout?.items.find((it) => it.e.kind === "pendant");
if (pendant && (light === "spot" || light === undefined)) {
const z = layout!.zoom;
const b = toScreen(pendant.x, pendant.y + 376 * pendant.s);
return { kind: "lamp", x: b.x, y: b.y, spread: 130 * pendant.s * z };
}
// Luminária de mesa acesa: brilho quente em volta da cúpula, o resto do lugar no escuro.
const desk = layout?.items.find((it) => it.e.kind === "desklamp");
if (desk && light === undefined) {
const k = desk.flip ? -1 : 1;
const a = toScreen(desk.x + k * 40 * desk.s, desk.y - 130 * desk.s);
return { kind: "glow", x: a.x, y: a.y, spread: 420 * desk.s * layout!.zoom };
}
if (light === "spot") return { kind: "lamp", x: W / 2, y: H * 0.045, spread: W * 0.07, fixture: true };
if (light !== undefined || !place || !layout) return null;
if (place.indoor) {
const win = layout.items.find((it) => it.e.kind === "window");
if (!win) return null;
const a = toScreen(win.x - 186 * win.s, win.y - 616 * win.s);
const b = toScreen(win.x + 186 * win.s, win.y - 244 * win.s);
return { kind: "window", x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, w: b.x - a.x, h: b.y - a.y };
}
const sun = sunOf(spec!.palette, layout.horizon);
if (!sun || isNight(spec!.palette)) return null;
return { kind: "sun", x: sun.x, y: sun.y };
}
/**
* Luz por cima de tudo (inclusive dos personagens). Fonte POSICIONADA: luminária (cone + poça no chão), janela
* (raios em diagonal + manchas no piso) ou sol (brilho quente). Contraste quente (luz) × frio (sombra).
* `light: "vignette"` escurece as bordas; `"none"` desliga; sem `light`, a fonte sai das peças do lugar.
*/
export function LightLayer({ light, palette: id, spec }: { light: ShotSpec["light"]; palette?: PaletteId; spec?: ShotSpec }) {
const pal = palette(id ?? spec?.palette);
const src = resolveLight(spec, light);
const vignette = light === "vignette";
if (!src && !vignette) return null;
const indoor = !!spec?.place?.indoor;
const horizon = spec?.place ? (spec.place.horizon ?? (indoor ? 0.62 : 0.56)) * H : H * 0.6;
const night = isNight(id ?? spec?.palette);
const warm = night && src?.kind === "window" ? "#a8c0ff" : pal.light;
const layers: React.ReactNode[] = [];
const defs: React.ReactNode[] = [];
if (src?.kind === "lamp") {
const floorY = indoor || !spec?.place ? Math.max(src.y + H * 0.3, horizon + (H - horizon) * 0.55) : H * 0.84;
const sw = src.spread ?? W * 0.08;
const spread = (floorY - src.y) * 0.42 + sw;
defs.push(<linearGradient key="c" id="lgCone" gradientUnits="userSpaceOnUse" x1="0" y1={src.y} x2="0" y2={floorY}>
<stop offset="0" stopColor={warm} stopOpacity={0.42} /><stop offset="1" stopColor={warm} stopOpacity={0.06} /></linearGradient>);
defs.push(<radialGradient key="p" id="lgPool"><stop offset="0" stopColor={warm} stopOpacity={0.4} /><stop offset="1" stopColor={warm} stopOpacity={0} /></radialGradient>);
defs.push(<radialGradient key="d" id="lgDark" gradientUnits="userSpaceOnUse" cx={src.x} cy={(src.y + floorY) / 2} r={H * 0.62}>
<stop offset="0.3" stopColor={pal.shade} stopOpacity={0} /><stop offset="1" stopColor={pal.shade} stopOpacity={0.62} /></radialGradient>);
layers.push(<rect key="dark" width={W} height={H} fill="url(#lgDark)" />);
layers.push(<polygon key="cone" points={`${src.x - sw * 0.92},${src.y} ${src.x + sw * 0.92},${src.y} ${src.x + spread},${floorY} ${src.x - spread},${floorY}`} fill="url(#lgCone)" />);
layers.push(<ellipse key="pool" cx={src.x} cy={floorY} rx={spread * 1.15} ry={spread * 0.2} fill="url(#lgPool)" />);
if (src.fixture) {
layers.push(<path key="fx" d={`M${src.x - sw} ${src.y} Q${src.x - sw * 0.9} ${src.y - 60} ${src.x} ${src.y - 64} Q${src.x + sw * 0.9} ${src.y - 60} ${src.x + sw} ${src.y} Z`} fill={mix(pal.ink, "#4a5270", 0.5)} />);
layers.push(<ellipse key="fxl" cx={src.x} cy={src.y} rx={sw} ry={12} fill={warm} />);
}
} else if (src?.kind === "window") {
const ww = src.w ?? W * 0.3;
const wh = src.h ?? H * 0.18;
const x0 = src.x - ww / 2;
const y0 = src.y - wh / 2;
const dir = src.x < W / 2 ? 1 : -1;
const vx = dir * W * 0.78;
const vy = H * 0.55;
const pane = (a: number, b: number) => {
// Retângulo da vidraça arrastado na direção dos raios (contorno convexo).
const xa = x0 + ww * a;
const xb = x0 + ww * b;
const [l, r] = dir > 0 ? [xa, xb] : [xb, xa];
return `${l},${y0} ${r},${y0} ${r + vx},${y0 + vy} ${r + vx},${y0 + wh + vy} ${l + vx},${y0 + wh + vy} ${l},${y0 + wh}`;
};
defs.push(<linearGradient key="b" id="lgBeam" gradientUnits="userSpaceOnUse" x1={src.x} y1={src.y} x2={src.x + vx} y2={src.y + vy}>
<stop offset="0" stopColor={warm} stopOpacity={night ? 0.16 : 0.34} /><stop offset="1" stopColor={warm} stopOpacity={0} /></linearGradient>);
defs.push(<radialGradient key="g" id="lgGlow" gradientUnits="userSpaceOnUse" cx={src.x} cy={src.y} r={W * 0.75}>
<stop offset="0" stopColor={warm} stopOpacity={night ? 0.12 : 0.24} /><stop offset="1" stopColor={warm} stopOpacity={0} /></radialGradient>);
defs.push(<linearGradient key="k" id="lgCool" x1={dir > 0 ? 1 : 0} y1="0" x2={dir > 0 ? 0 : 1} y2="0">
<stop offset="0" stopColor={pal.shade} stopOpacity={0.4} /><stop offset="0.6" stopColor={pal.shade} stopOpacity={0} /></linearGradient>);
layers.push(<rect key="cool" width={W} height={H} fill="url(#lgCool)" />);
layers.push(<rect key="glow" width={W} height={H} fill="url(#lgGlow)" />);
layers.push(<polygon key="b1" points={pane(0, 0.47)} fill="url(#lgBeam)" />);
layers.push(<polygon key="b2" points={pane(0.53, 1)} fill="url(#lgBeam)" />);
// Manchas da janela no piso, inclinadas no sentido dos raios.
const fy = horizon + (H - horizon) * 0.3;
const fh = (H - horizon) * 0.2;
const cx = src.x + dir * W * 0.38;
const sk = dir * fh * 0.9;
for (const [a, b] of [[-0.62, -0.03], [0.03, 0.62]]) {
const xa = cx + ww * a;
const xb = cx + ww * b;
layers.push(<polygon key={`f${a}`} points={`${xa},${fy} ${xb},${fy} ${xb + sk},${fy + fh} ${xa + sk},${fy + fh}`} fill={warm} opacity={night ? 0.08 : 0.2} />);
}
} else if (src?.kind === "glow") {
const r = Math.max(W * 0.35, src.spread ?? W * 0.4);
defs.push(<radialGradient key="g" id="lgGlow" gradientUnits="userSpaceOnUse" cx={src.x} cy={src.y} r={r}>
<stop offset="0" stopColor={warm} stopOpacity={0.38} /><stop offset="1" stopColor={warm} stopOpacity={0} /></radialGradient>);
defs.push(<radialGradient key="d" id="lgDark" gradientUnits="userSpaceOnUse" cx={src.x} cy={src.y} r={H * 0.7}>
<stop offset="0.25" stopColor={pal.shade} stopOpacity={0} /><stop offset="1" stopColor={pal.shade} stopOpacity={0.6} /></radialGradient>);
layers.push(<rect key="dark" width={W} height={H} fill="url(#lgDark)" />);
layers.push(<rect key="glow" width={W} height={H} fill="url(#lgGlow)" />);
} else if (src?.kind === "sun") {
defs.push(<radialGradient key="s" id="lgSun" gradientUnits="userSpaceOnUse" cx={src.x} cy={src.y} r={W * 1.05}>
<stop offset="0" stopColor={warm} stopOpacity={0.26} /><stop offset="0.5" stopColor={warm} stopOpacity={0.06} /><stop offset="1" stopColor={warm} stopOpacity={0} /></radialGradient>);
defs.push(<linearGradient key="k" id="lgCool" x1="1" y1="1" x2="0.3" y2="0.4">
<stop offset="0" stopColor={pal.shade} stopOpacity={0.3} /><stop offset="1" stopColor={pal.shade} stopOpacity={0} /></linearGradient>);
layers.push(<rect key="cool" width={W} height={H} fill="url(#lgCool)" />);
layers.push(<rect key="sun" width={W} height={H} fill="url(#lgSun)" />);
}
if (vignette) {
defs.push(<radialGradient key="v" id="lgVig" cx="0.5" cy="0.45" r="0.75"><stop offset="0.55" stopColor="#000" stopOpacity={0} /><stop offset="1" stopColor="#000" stopOpacity={0.55} /></radialGradient>);
layers.push(<rect key="vig" width={W} height={H} fill="url(#lgVig)" />);
} }
return ( return (
<svg viewBox={`0 0 ${W} ${H}`} width="100%" height="100%" preserveAspectRatio="xMidYMid slice" style={{ position: "absolute", inset: 0 }}> <svg viewBox={`0 0 ${W} ${H}`} width="100%" height="100%" preserveAspectRatio="xMidYMid slice" style={{ position: "absolute", inset: 0 }}>
<defs> <defs>{defs}</defs>
<linearGradient id="spot" x1="0" y1="0" x2="0" y2="1"><stop offset="0" stopColor={pal.light} stopOpacity={0.32} /><stop offset="1" stopColor={pal.light} stopOpacity={0.05} /></linearGradient> {layers}
<radialGradient id="spotDark" cx="0.5" cy="0.55" r="0.65"><stop offset="0.35" stopColor="#000" stopOpacity={0} /><stop offset="1" stopColor="#000" stopOpacity={0.6} /></radialGradient> </svg>
</defs> );
<rect width={W} height={H} fill="url(#spotDark)" /> }
<polygon points={`${W * 0.44},${H * 0.03} ${W * 0.56},${H * 0.03} ${W * 0.86},${H * 0.75} ${W * 0.14},${H * 0.75}`} fill="url(#spot)" />
<rect x={W * 0.42} y={H * 0.025} width={W * 0.16} height={14} rx={6} fill="#d9d9d9" /> /** Chuva por cima de tudo (inclusive dos personagens); tempestade escurece, chove mais e relampeja. */
<ellipse cx={W / 2} cy={H * 0.75} rx={W * 0.36} ry={34} fill={pal.light} opacity={0.12} /> export function WeatherLayer({ spec, frame }: { spec: ShotSpec; frame: number }) {
const weather = spec.place?.weather ?? "none";
if (weather === "none") return null;
const storm = weather === "storm";
const rand = rng(spec.seed + 101);
const drops = Array.from({ length: storm ? 230 : 130 }, () => ({ x: rand() * (W + 300), y: rand() * H, v: 38 + rand() * 26, l: 40 + rand() * 50 }));
// Relâmpago: um clarão curto a cada 2,5 s, com fase que depende da semente.
const cycle = 75;
const ph = (frame + (spec.seed % cycle)) % cycle;
const flash = storm && ph < 5 ? (ph < 2 ? 0.55 : 0.25) : 0;
return (
<svg viewBox={`0 0 ${W} ${H}`} width="100%" height="100%" preserveAspectRatio="xMidYMid slice" style={{ position: "absolute", inset: 0 }}>
{storm && <rect width={W} height={H} fill="#0a1020" opacity={0.22} />}
<g stroke="#d6e4f5" strokeWidth={storm ? 3.4 : 2.6} strokeLinecap="round" opacity={storm ? 0.6 : 0.5}>
{drops.map((d, i) => {
const y = ((d.y + frame * d.v) % (H + 120)) - 60;
const x = ((((d.x - frame * d.v * 0.22) % (W + 300)) + W + 300) % (W + 300)) - 150;
return <line key={i} x1={x} y1={y} x2={x - d.l * 0.22} y2={y + d.l} />;
})}
</g>
{flash > 0 && <>
<rect width={W} height={H} fill="#eaf2ff" opacity={flash} />
<path d={`M${W * 0.7} 0 L${W * 0.64} ${H * 0.14} L${W * 0.69} ${H * 0.14} L${W * 0.6} ${H * 0.3}`} stroke="#ffffff" strokeWidth={9} fill="none" strokeLinejoin="round" />
</>}
</svg>
);
}
/**
* Por cima dos personagens: a parte da frente das peças ocupadas (casco da arca, lataria do carro), na mesma
* posição da peça no fundo — quem está "dentro" aparece da cintura para cima.
*/
export function PlaceForeground({ spec, frame, progress = 0 }: { spec: ShotSpec; frame: number; progress?: number }) {
const place = spec.place;
const layout = React.useMemo(() => (place ? layoutPlace(spec) : null), [spec, place]);
if (!place || !layout || !place.elements.some((e) => e.occupied && FRONT_PART[e.kind])) return null;
const pal = palette(spec.palette);
const hazeColor = place.indoor ? pal.wall : mix(mix(pal.sky[2], pal.sky[1], 0.25), "#c8ccd6", place.fog ? 0.45 : 0);
const level = floodLevel(place, progress);
const waterY = level === null ? null : level * H;
const storm = place.weather === "storm";
const { horizon, zoom } = layout;
const zoomT = zoom === 1 ? undefined : `translate(${W / 2} ${horizon}) scale(${zoom}) translate(${-W / 2} ${-horizon})`;
return (
<svg viewBox={`0 0 ${W} ${H}`} width="100%" height="100%" preserveAspectRatio="xMidYMid slice" style={{ position: "absolute", inset: 0 }}>
<g transform={zoomT}>
{layout.items.filter((it) => it.e.occupied && FRONT_PART[it.e.kind]).map((it) => {
const floating = !!it.e.float && waterY !== null;
return <PlacedElement key={it.e.i} it={it} pal={pal} spec={spec} hazeColor={hazeColor} part="front"
y={floating ? waterY! + H * 0.035 + Math.sin(frame / 14 + it.e.i) * 9 : undefined}
rot={floating ? Math.sin(frame / 22 + it.e.i) * (storm ? 3.5 : 1.6) : 0} />;
})}
{waterY !== null && place.elements.some((e) => e.occupied && e.float) && <rect x={0} y={waterY + H * 0.03} width={W} height={H} fill={pal.ground.water} opacity={0.35} />}
</g>
</svg> </svg>
); );
} }
+167
View File
@@ -0,0 +1,167 @@
// Rig do personagem: o rosto e o corpo são PARÂMETROS contínuos, não desenhos prontos. Uma expressão ou uma
// pose é só um conjunto de valores; dá para misturar (blend), ajustar um valor ("sorriso 0,3 a mais") e criar
// novas sem mexer no desenho. Ângulos em graus; "para fora" positivo nos dois lados (o desenho espelha).
export type FaceParams = {
/** Sobrancelha: y (px; negativo sobe) e tilt (graus; positivo = ponta de dentro sobe, como triste/preocupado). */
browL: { y: number; tilt: number };
browR: { y: number; tilt: number };
/** Abertura dos olhos (0 fechado · 1 normal · 1,35 arregalado). */
eyeL: number;
eyeR: number;
/** Tamanho da pupila (0,4 pavor · 1 normal · 1,3 encantado). */
pupil: number;
/** Direção do olhar (-1…1). */
gazeX: number;
gazeY: number;
/** Boca: abertura 0…1, sorriso -1 (triste) … 1 (feliz), largura 0,5…1,4, dentes à mostra. */
mouthOpen: number;
smile: number;
mouthWidth: number;
/** Arredondamento dos lábios (0 normal … 1 bico de "o/u"): vem da fala (lipsync.ts). */
mouthRound: number;
/** Pálpebra de cima somada à de base do personagem (−0,5 arregala … 0,6 quase fecha). */
lid: number;
teeth: boolean;
/** Extras: rubor 0…1, gota de suor, lágrimas, veia de raiva. */
blush: number;
sweat: boolean;
tears: boolean;
anger: boolean;
};
export type Limb = {
/** Abertura a partir do corpo (0 = para baixo; 90 = horizontal para fora; 180 = para cima). */
raise: number;
/** Dobra do cotovelo/joelho (positivo = antebraço/canela para dentro, na frente do corpo). */
bend: number;
};
export type BodyParams = {
/** Inclinação do tronco (graus; positivo = para a direita de quem olha). */
lean: number;
/** Cabeça: inclinação (graus), virada (-1…1, finge 3/4) e aceno (-1 olha para cima … 1 para baixo). */
headTilt: number;
headTurn: number;
headNod: number;
armL: Limb;
armR: Limb;
legL: Limb;
legR: Limb;
/** Agachar/sentar: 0 em pé … 1 sentado (quadril desce, coxa encurta em perspectiva). */
crouch: number;
};
export const NEUTRAL_FACE: FaceParams = {
browL: { y: 0, tilt: 0 }, browR: { y: 0, tilt: 0 }, eyeL: 1, eyeR: 1, pupil: 1, gazeX: 0, gazeY: 0,
mouthOpen: 0, smile: 0.1, mouthWidth: 1, mouthRound: 0, lid: 0, teeth: false, blush: 0, sweat: false, tears: false, anger: false,
};
export const NEUTRAL_BODY: BodyParams = {
lean: 0, headTilt: 0, headTurn: 0, headNod: 0,
armL: { raise: 8, bend: 6 }, armR: { raise: 8, bend: 6 }, legL: { raise: 2, bend: 0 }, legR: { raise: 2, bend: 0 }, crouch: 0,
};
type FacePatch = Partial<Omit<FaceParams, "browL" | "browR">> & { browL?: Partial<FaceParams["browL"]>; browR?: Partial<FaceParams["browR"]>; brows?: Partial<FaceParams["browL"]>; eyes?: number };
type BodyPatch = Partial<Omit<BodyParams, "armL" | "armR" | "legL" | "legR">> & { armL?: Partial<Limb>; armR?: Partial<Limb>; legL?: Partial<Limb>; legR?: Partial<Limb>; arms?: Partial<Limb>; legs?: Partial<Limb> };
/** Aplica um ajuste parcial (aceita `brows`/`eyes`/`arms`/`legs` para os dois lados de uma vez). */
export function withFace(base: FaceParams, p: FacePatch = {}): FaceParams {
const { brows, eyes, browL, browR, ...rest } = p;
return {
...base, ...rest,
browL: { ...base.browL, ...brows, ...browL }, browR: { ...base.browR, ...brows, ...browR },
eyeL: rest.eyeL ?? eyes ?? base.eyeL, eyeR: rest.eyeR ?? eyes ?? base.eyeR,
};
}
export function withBody(base: BodyParams, p: BodyPatch = {}): BodyParams {
const { arms, legs, armL, armR, legL, legR, ...rest } = p;
return {
...base, ...rest,
armL: { ...base.armL, ...arms, ...armL }, armR: { ...base.armR, ...arms, ...armR },
legL: { ...base.legL, ...legs, ...legL }, legR: { ...base.legR, ...legs, ...legR },
};
}
/** Expressões prontas = atalhos de parâmetros (dá para ajustar qualquer valor por cima com `face`). */
export const EXPRESSION_PRESETS = {
neutral: {},
smile: { smile: 0.7, eyes: 0.9 },
happy: { smile: 0.9, mouthOpen: 0.3, teeth: true, eyes: 0.85, brows: { y: -3 } },
laugh: { smile: 1, mouthOpen: 0.75, teeth: true, eyes: 0.18, brows: { y: -5 }, blush: 0.4 },
proud: { smile: 0.6, lid: 0.35, brows: { y: -2 } },
sad: { smile: -0.7, brows: { tilt: 16 }, eyes: 0.8, gazeY: 0.5 },
cry: { smile: -0.9, mouthOpen: 0.35, brows: { tilt: 20 }, eyes: 0.4, tears: true },
worried: { smile: -0.3, brows: { tilt: 14, y: -2 }, eyes: 1.05, sweat: true },
angry: { smile: -0.4, brows: { tilt: -18, y: 3 }, lid: 0.25, mouthWidth: 0.9 },
furious: { smile: -0.6, mouthOpen: 0.6, teeth: true, brows: { tilt: -24, y: 4 }, lid: 0.3, anger: true },
surprised: { mouthOpen: 0.6, mouthWidth: 0.55, smile: 0, brows: { y: -8 }, eyes: 1.25, pupil: 0.8, lid: -0.5 },
scared: { mouthOpen: 0.5, mouthWidth: 0.9, smile: -0.5, teeth: true, brows: { tilt: 18, y: -6 }, eyes: 1.3, pupil: 0.55, sweat: true, lid: -0.5 },
shocked: { mouthOpen: 0.95, mouthWidth: 0.6, smile: 0, brows: { y: -10 }, eyes: 1.35, pupil: 0.45, lid: -0.5 },
suspicious: { smile: -0.1, mouthWidth: 0.8, browL: { y: -6, tilt: 0 }, browR: { y: 4, tilt: -10 }, lid: 0.45, gazeX: 0.6 },
smirk: { smile: 0.45, mouthWidth: 0.8, browL: { y: -5 }, lid: 0.3, gazeX: -0.3 },
confused: { smile: -0.2, mouthWidth: 0.75, browL: { y: -7 }, browR: { tilt: -8 }, gazeY: -0.6, gazeX: 0.4 },
disgusted: { smile: -0.7, mouthWidth: 1.1, brows: { tilt: -10, y: 2 }, lid: 0.35 },
sleepy: { lid: 0.6, brows: { y: 3 }, mouthOpen: 0.1, smile: 0 },
determined: { smile: 0.1, mouthWidth: 0.85, brows: { tilt: -10, y: 2 }, lid: 0.2 },
embarrassed: { smile: 0.3, blush: 1, gazeY: 0.6, gazeX: -0.4, eyes: 0.8, sweat: true },
} satisfies Record<string, FacePatch>;
/** Poses prontas = atalhos de ângulos (ajustáveis por cima com `body`). */
export const POSE_PRESETS = {
stand: {},
point: { armR: { raise: 92, bend: 0 } },
wave: { armR: { raise: 140, bend: -25 } },
hold: { armR: { raise: 28, bend: 75 } },
arms_up: { arms: { raise: 158, bend: -10 } },
celebrate: { arms: { raise: 150, bend: -30 }, headNod: -0.4 },
shrug: { arms: { raise: 38, bend: 100 }, headTilt: 7 },
think: { armR: { raise: -19, bend: 141 }, headTilt: -6 },
hands_on_hips: { arms: { raise: 42, bend: 105 } },
cross_arms: { arms: { raise: 22, bend: 128 } },
facepalm: { armR: { raise: 125, bend: -103 }, headNod: 0.5, headTilt: 8 },
cover_mouth: { armR: { raise: -60, bend: 119 } },
defend: { arms: { raise: 62, bend: 118 }, lean: -4 },
reach: { armR: { raise: 70, bend: -10 }, lean: 6 },
sit: { crouch: 1, arms: { raise: 14, bend: 40 } },
kneel: { crouch: 0.6, arms: { raise: 10, bend: 20 } },
lean_in: { lean: 8, headTilt: 6 },
// Duas mãos segurando um objeto largo (livro, tábua) pelas bordas, na frente do peito.
hold_both: { arms: { raise: 51, bend: 99 } },
// Joinha: cotovelo dobrado, mão na altura do peito/ombro (a forma da mão vem do desenho: `thumbs_up`).
thumbs_up: { armR: { raise: 17, bend: 149 } },
} satisfies Record<string, BodyPatch>;
export type ExpressionName = keyof typeof EXPRESSION_PRESETS;
export type PoseName = keyof typeof POSE_PRESETS;
export const EXPRESSION_NAMES = Object.keys(EXPRESSION_PRESETS) as ExpressionName[];
export const POSE_NAMES = Object.keys(POSE_PRESETS) as PoseName[];
export const faceOf = (name: string | undefined, patch?: FacePatch): FaceParams =>
withFace(withFace(NEUTRAL_FACE, (EXPRESSION_PRESETS as Record<string, FacePatch>)[name ?? "neutral"] ?? {}), patch);
export const bodyOf = (name: string | undefined, patch?: BodyPatch): BodyParams =>
withBody(withBody(NEUTRAL_BODY, (POSE_PRESETS as Record<string, BodyPatch>)[name ?? "stand"] ?? {}), patch);
const lerp = (a: number, b: number, k: number) => a + (b - a) * k;
const limb = (a: Limb, b: Limb, k: number): Limb => ({ raise: lerp(a.raise, b.raise, k), bend: lerp(a.bend, b.bend, k) });
/** Mistura duas expressões (k = 0 → a, 1 → b). Os "liga/desliga" trocam na metade. */
export function blendFace(a: FaceParams, b: FaceParams, k: number): FaceParams {
const pick = <T,>(x: T, y: T) => (k < 0.5 ? x : y);
return {
browL: { y: lerp(a.browL.y, b.browL.y, k), tilt: lerp(a.browL.tilt, b.browL.tilt, k) },
browR: { y: lerp(a.browR.y, b.browR.y, k), tilt: lerp(a.browR.tilt, b.browR.tilt, k) },
eyeL: lerp(a.eyeL, b.eyeL, k), eyeR: lerp(a.eyeR, b.eyeR, k), pupil: lerp(a.pupil, b.pupil, k),
gazeX: lerp(a.gazeX, b.gazeX, k), gazeY: lerp(a.gazeY, b.gazeY, k),
mouthOpen: lerp(a.mouthOpen, b.mouthOpen, k), smile: lerp(a.smile, b.smile, k), mouthWidth: lerp(a.mouthWidth, b.mouthWidth, k), mouthRound: lerp(a.mouthRound, b.mouthRound, k), lid: lerp(a.lid, b.lid, k),
teeth: pick(a.teeth, b.teeth), blush: lerp(a.blush, b.blush, k), sweat: pick(a.sweat, b.sweat), tears: pick(a.tears, b.tears), anger: pick(a.anger, b.anger),
};
}
export function blendBody(a: BodyParams, b: BodyParams, k: number): BodyParams {
return {
lean: lerp(a.lean, b.lean, k), headTilt: lerp(a.headTilt, b.headTilt, k), headTurn: lerp(a.headTurn, b.headTurn, k), headNod: lerp(a.headNod, b.headNod, k),
armL: limb(a.armL, b.armL, k), armR: limb(a.armR, b.armR, k), legL: limb(a.legL, b.legL, k), legR: limb(a.legR, b.legR, k), crouch: lerp(a.crouch, b.crouch, k),
};
}
export type { FacePatch, BodyPatch };
+1 -1
View File
@@ -152,7 +152,7 @@ function Card({ spec }: SceneProps) {
export function SceneBackground(props: SceneProps) { export function SceneBackground(props: SceneProps) {
switch (props.spec.scene.kind) { switch (props.spec.scene.kind) {
case "place": return <PlaceBackground spec={props.spec} frame={props.frame} />; case "place": return <PlaceBackground spec={props.spec} frame={props.frame} progress={props.progress} />;
case "street": return <Street {...props} />; case "street": return <Street {...props} />;
case "house": return <HouseFront {...props} />; case "house": return <HouseFront {...props} />;
case "blueprint": return <Blueprint />; case "blueprint": return <Blueprint />;
+158 -14
View File
@@ -3,7 +3,10 @@
// do quadro (0 = esquerda/topo, 1 = direita/base). Tempos em segundos, a partir do início do trecho. // do quadro (0 = esquerda/topo, 1 = direita/base). Tempos em segundos, a partir do início do trecho.
import { EXPRESSIONS, POSES, validateLook, type CharacterLook, type Expression, type Pose } from "./character"; import { EXPRESSIONS, POSES, validateLook, type CharacterLook, type Expression, type Pose } from "./character";
import { ELEMENTS, GROUNDS, PALETTES, type PaletteId, type Place } from "./places"; import { validateTimeline, type Action } from "./motion";
import type { BodyPatch, FacePatch } from "./rig";
import { ELEMENTS, GROUNDS, LIGHT_SOURCES, PALETTES, WEATHERS, type PaletteId, type Place } from "./places";
import { SPECIES, type Species } from "./animals";
/** "place" = lugar montado por peças (ver places.tsx); os demais são fundos prontos da 1ª versão. */ /** "place" = lugar montado por peças (ver places.tsx); os demais são fundos prontos da 1ª versão. */
export const SCENES = ["place", "street", "house", "plain", "blueprint", "card"] as const; export const SCENES = ["place", "street", "house", "plain", "blueprint", "card"] as const;
@@ -11,7 +14,8 @@ export const LIGHTS = ["none", "spot", "vignette"] as const;
export type SceneKind = (typeof SCENES)[number]; export type SceneKind = (typeof SCENES)[number];
export const TIMES = ["night", "dawn", "day"] as const; export const TIMES = ["night", "dawn", "day"] as const;
export type TimeOfDay = (typeof TIMES)[number]; export type TimeOfDay = (typeof TIMES)[number];
export const ICONS = ["house", "generator", "fuel", "battery", "phone", "door", "eye", "bulb", "solar", "warning", "money", "clock"] as const; export const ICONS = ["house", "generator", "fuel", "battery", "phone", "door", "eye", "bulb", "solar", "warning", "money", "clock",
"olive", "hammer", "tablet", "book", "ruler"] as const;
export type IconId = (typeof ICONS)[number]; export type IconId = (typeof ICONS)[number];
export const TONES = ["info", "danger", "ok"] as const; export const TONES = ["info", "danger", "ok"] as const;
export type Tone = (typeof TONES)[number]; export type Tone = (typeof TONES)[number];
@@ -27,6 +31,13 @@ export type Person = {
item?: IconId; item?: IconId;
/** Olha para a esquerda (espelha o desenho). */ /** Olha para a esquerda (espelha o desenho). */
flip?: boolean; flip?: boolean;
/** Enquadramento: corpo inteiro (padrão), meio corpo ou de perto (rosto grande, como ilustração de destaque). */
framing?: "full" | "medium" | "close" | "insert";
/** Ajuste fino por cima da expressão/pose (ex.: { smile: 0.3, browL: { y: -6 } } ou { armR: { raise: 60 } }). */
face?: FacePatch;
body?: BodyPatch;
/** Movimento: ações com início (at/atP/cue) — andar, pular, falar, trocar de expressão… (motion.ts). */
timeline?: Action[];
/** Cor da roupa (hex). */ /** Cor da roupa (hex). */
outfit?: string; outfit?: string;
hair?: "short" | "bun" | "none"; hair?: "short" | "bun" | "none";
@@ -39,7 +50,22 @@ export type Person = {
enterS?: number; enterS?: number;
}; };
export type Crowd = { kind: "crowd"; count: number; y: number; enterS?: number }; export type Crowd = { kind: "crowd"; count: number; y: number; enterS?: number };
export type Actor = Person | Crowd; /**
* Animal (figura reaproveitável, animals.tsx). `count` > 1 = fila (um atrás do outro, `gap` entre eles); `pair` =
* casal lado a lado em cada lugar da fila. `walk` anda de x até `to` (aves com `fly` voam, subindo e descendo).
* Olha para a direita; anda para a esquerda = espelha sozinho. `carry: "olive"` = ramo no bico (aves).
*/
export type Animal = {
kind: "animal";
species: Species;
x: number; y: number; scale?: number; flip?: boolean; color?: string;
count?: number; gap?: number; pair?: boolean;
walk?: { to: number; startS?: number; dur?: number };
fly?: boolean;
carry?: "olive";
enterS?: number;
};
export type Actor = Person | Crowd | Animal;
export type Prop = { export type Prop = {
icon: IconId; icon: IconId;
@@ -54,16 +80,57 @@ export type Prop = {
crossed?: boolean; crossed?: boolean;
}; };
/**
* Camadas de texto/grafismo por cima da cena (overlays.tsx). `text` é o rótulo de cada uma:
* - onomatopoeia | tag | big: o texto em si; counter: rótulo pequeno + `value` grande (caixa escura arredondada);
* - namecard: nome do personagem + `lines` (função, dado) num cartão claro;
* - stat: rótulo espaçado + `value` grande colorido por `tone` (danger vermelho, info amarelo, ok verde, sem = branco);
* - checklist: `items` com `state` (empty | checked | crossed) que vão se marcando em sequência (`stepS`);
* - table: `items` ({ text, value }) com a linha `highlight` destacada; `text` = título (pode ser "");
* - progress: rótulo + barra que enche até `value` (0–100) + porcentagem;
* - grid: `value` de `total` quadradinhos preenchidos (com o número) + "N DE M".
* `panel: true` = cartela sobre fundo escuro de tela inteira; sem ele, caixa escura flutuante sobre a cena.
*/
export const TEXT_KINDS = ["onomatopoeia", "tag", "counter", "big", "namecard", "stat", "checklist", "table", "progress", "grid"] as const;
export type TextKind = (typeof TEXT_KINDS)[number];
export const CHECK_STATES = ["empty", "checked", "crossed"] as const;
export type CheckState = (typeof CHECK_STATES)[number];
export type TextRow = { text: string; value?: string; state?: CheckState };
export type TextItem = { export type TextItem = {
kind: "onomatopoeia" | "tag" | "counter" | "big"; kind: TextKind;
text: string; text: string;
/** Só no "counter": o número grande embaixo do rótulo. */ /** counter/stat: o número grande; progress: 0–100; grid: quantos quadradinhos preenchidos. */
value?: string; value?: string | number;
x: number; y: number; x: number; y: number;
atS?: number; atS?: number;
tone?: Tone; tone?: Tone;
/** Graus (onomatopeia costuma ir levemente girada). */ /** Graus (onomatopeia costuma ir levemente girada). */
rotate?: number; rotate?: number;
/** namecard: 1–2 linhas menores embaixo do nome (função, dado). */
lines?: string[];
/** checklist/table: as linhas. */
items?: TextRow[];
/** table: índice da linha destacada. */
highlight?: number;
/** grid: total de quadradinhos (1–40). */
total?: number;
/** checklist: segundos entre uma marcação e a próxima (padrão 0,5). */
stepS?: number;
/** Cartela sobre fundo escuro de tela inteira (senão, caixa flutuante sobre a cena). */
panel?: boolean;
/** Escala da cartela (padrão 1; 0,5 = lista pequena no canto). */
size?: number;
};
/**
* Painel do topo. Esquerda: `badge` (bloco amarelo, "DIA 3") + `clock` (hora, anda com `clockMinutesPerSecond`) e,
* embaixo, a faixa clara com `place` (ou `label`). Direita, opcional: `valueLabel` pequeno ("CAIXA") + `value` grande
* (`valueTone`; sem ele, zero/negativo fica vermelho) e a faixa amarela `note` ("ESTREIA EM 30 DIAS").
*/
export type Hud = {
badge: string; label: string; clock?: string; clockMinutesPerSecond?: number;
place?: string; value?: string; valueLabel?: string; valueTone?: Tone; note?: string;
}; };
export type Word = { text: string; startS: number; endS: number; tone?: "key" | "danger" }; export type Word = { text: string; startS: number; endS: number; tone?: "key" | "danger" };
@@ -78,16 +145,23 @@ export type ShotSpec = {
palette?: PaletteId; palette?: PaletteId;
/** Lugar montado por peças (scene.kind "place"). */ /** Lugar montado por peças (scene.kind "place"). */
place?: Place; place?: Place;
/** Textura de papel por cima (0 desliga; padrão 0,11). */
grain?: number;
/** Luz por cima: foco do teto ("spot") ou vinheta. */ /** Luz por cima: foco do teto ("spot") ou vinheta. */
light?: (typeof LIGHTS)[number]; light?: (typeof LIGHTS)[number];
/** Fonte de luz posicionada (opcional): luminária (cone + poça no chão), janela (raios em diagonal) ou sol.
* x/y em fração do quadro. Sem ela, a luz sai das peças do lugar (luminária pendente > janela > sol). */
lightSource?: { kind: (typeof LIGHT_SOURCES)[number]; x: number; y?: number };
/** push = zoom no fim do trecho (1 = parado); panX = deslocamento horizontal da câmera (fração). */ /** push = zoom no fim do trecho (1 = parado); panX = deslocamento horizontal da câmera (fração). */
camera?: { push?: number; panX?: number }; camera?: { push?: number; panX?: number };
hud?: { badge: string; label: string; clock?: string; clockMinutesPerSecond?: number }; hud?: Hud;
actors?: Actor[]; actors?: Actor[];
props?: Prop[]; props?: Prop[];
texts?: TextItem[]; texts?: TextItem[];
/** Legenda palavra por palavra (tempos da narração). Vazio = sem legenda. */ /** Legenda palavra por palavra (tempos da narração). Vazio = sem legenda. A boca de quem "fala" usa os mesmos tempos. */
words?: Word[]; words?: Word[];
/** Volume do áudio do trecho quadro a quadro (0–1): fecha a boca nas pausas e abre nas sílabas fortes. */
audioEnv?: { fps: number; values: number[] };
card?: { title: string; subtitle?: string; footer?: string }; card?: { title: string; subtitle?: string; footer?: string };
}; };
@@ -111,6 +185,12 @@ export function validateSpec(spec: unknown): string[] {
if (s.scene?.kind === "card" && !s.card?.title) errors.push("scene card precisa de card.title"); if (s.scene?.kind === "card" && !s.card?.title) errors.push("scene card precisa de card.title");
if (s.palette !== undefined && !PALETTES.includes(s.palette)) errors.push(`palette precisa ser um de: ${PALETTES.join(", ")}`); if (s.palette !== undefined && !PALETTES.includes(s.palette)) errors.push(`palette precisa ser um de: ${PALETTES.join(", ")}`);
if (s.light !== undefined && !LIGHTS.includes(s.light)) errors.push(`light precisa ser um de: ${LIGHTS.join(", ")}`); if (s.light !== undefined && !LIGHTS.includes(s.light)) errors.push(`light precisa ser um de: ${LIGHTS.join(", ")}`);
if (s.lightSource !== undefined) {
const ls = s.lightSource;
if (!ls || !LIGHT_SOURCES.includes(ls.kind) || !frac(ls.x) || (ls.y !== undefined && !frac(ls.y))) {
errors.push(`lightSource: { kind (${LIGHT_SOURCES.join(", ")}), x, y? } em fração do quadro`);
}
}
if (s.scene?.kind === "place") { if (s.scene?.kind === "place") {
const place = s.place; const place = s.place;
if (!place || !GROUNDS.includes(place.ground) || !Array.isArray(place.elements)) errors.push(`place precisa de ground (${GROUNDS.join(", ")}) e elements`); if (!place || !GROUNDS.includes(place.ground) || !Array.isArray(place.elements)) errors.push(`place precisa de ground (${GROUNDS.join(", ")}) e elements`);
@@ -119,7 +199,10 @@ export function validateSpec(spec: unknown): string[] {
for (const [i, e] of place.elements.entries()) { for (const [i, e] of place.elements.entries()) {
if (!ELEMENTS.includes(e.kind)) errors.push(`place.elements[${i}]: peça "${e.kind}" não existe (${ELEMENTS.join(", ")})`); if (!ELEMENTS.includes(e.kind)) errors.push(`place.elements[${i}]: peça "${e.kind}" não existe (${ELEMENTS.join(", ")})`);
if (!frac(e.x) || (e.z !== undefined && !(e.z >= 0 && e.z <= 1))) errors.push(`place.elements[${i}]: x fora do quadro ou z fora de 0–1`); if (!frac(e.x) || (e.z !== undefined && !(e.z >= 0 && e.z <= 1))) errors.push(`place.elements[${i}]: x fora do quadro ou z fora de 0–1`);
if (e.lift !== undefined && !(finite(e.lift) && e.lift >= -0.5 && e.lift <= 1)) errors.push(`place.elements[${i}]: lift entre -0,5 e 1`);
} }
if (place.weather !== undefined && !WEATHERS.includes(place.weather)) errors.push(`place.weather: ${WEATHERS.join(", ")}`);
if (place.flood !== undefined && !(place.flood && frac(place.flood.from) && frac(place.flood.to))) errors.push("place.flood: { from, to } em fração da altura");
} }
} }
for (const [i, a] of (s.actors ?? []).entries()) { for (const [i, a] of (s.actors ?? []).entries()) {
@@ -129,24 +212,85 @@ export function validateSpec(spec: unknown): string[] {
} else if (a.kind === "person" && a.expression !== undefined && !EXPRESSIONS.includes(a.expression)) errors.push(`actors[${i}]: expressão (${EXPRESSIONS.join(", ")})`); } else if (a.kind === "person" && a.expression !== undefined && !EXPRESSIONS.includes(a.expression)) errors.push(`actors[${i}]: expressão (${EXPRESSIONS.join(", ")})`);
else if (a.kind === "person" && a.pose !== undefined && !POSES.includes(a.pose)) errors.push(`actors[${i}]: pose (${POSES.join(", ")})`); else if (a.kind === "person" && a.pose !== undefined && !POSES.includes(a.pose)) errors.push(`actors[${i}]: pose (${POSES.join(", ")})`);
else if (a.kind === "person" && a.item !== undefined && !ICONS.includes(a.item)) errors.push(`actors[${i}]: item "${a.item}" não existe`); else if (a.kind === "person" && a.item !== undefined && !ICONS.includes(a.item)) errors.push(`actors[${i}]: item "${a.item}" não existe`);
else if (a.kind === "person") {
for (const e of validateTimeline(a.timeline)) errors.push(`actors[${i}].${e}`);
for (const [j, act] of (a.timeline ?? []).entries()) {
if (act.expression !== undefined && !EXPRESSIONS.includes(act.expression as Expression)) errors.push(`actors[${i}].timeline[${j}]: expressão "${act.expression}" não existe`);
if (act.pose !== undefined && !POSES.includes(act.pose as Pose)) errors.push(`actors[${i}].timeline[${j}]: pose "${act.pose}" não existe`);
}
}
else if (a.kind === "crowd" && (!finite(a.count) || a.count < 1 || a.count > 40 || !frac(a.y))) errors.push(`actors[${i}]: crowd inválida`); else if (a.kind === "crowd" && (!finite(a.count) || a.count < 1 || a.count > 40 || !frac(a.y))) errors.push(`actors[${i}]: crowd inválida`);
else if (a.kind !== "person" && a.kind !== "crowd") errors.push(`actors[${i}]: kind inválido`); else if (a.kind === "animal") {
if (!SPECIES.includes(a.species)) errors.push(`actors[${i}]: espécie "${a.species}" não existe (${SPECIES.join(", ")})`);
if (!frac(a.x) || !frac(a.y)) errors.push(`actors[${i}]: x/y fora do quadro`);
if (a.count !== undefined && !(Number.isInteger(a.count) && a.count >= 1 && a.count <= 12)) errors.push(`actors[${i}]: count entre 1 e 12`);
if (a.walk !== undefined && !(a.walk && frac(a.walk.to))) errors.push(`actors[${i}]: walk.to fora do quadro`);
if (a.carry !== undefined && a.carry !== "olive") errors.push(`actors[${i}]: carry só "olive"`);
}
else if (!["crowd", "person", "animal"].includes((a as { kind: string }).kind)) errors.push(`actors[${i}]: kind inválido`);
} }
for (const [i, p] of (s.props ?? []).entries()) { for (const [i, p] of (s.props ?? []).entries()) {
if (!ICONS.includes(p.icon)) errors.push(`props[${i}]: ícone "${p.icon}" não existe (${ICONS.join(", ")})`); if (!ICONS.includes(p.icon)) errors.push(`props[${i}]: ícone "${p.icon}" não existe (${ICONS.join(", ")})`);
if (!frac(p.x) || !frac(p.y)) errors.push(`props[${i}]: x/y fora do quadro`); if (!frac(p.x) || !frac(p.y)) errors.push(`props[${i}]: x/y fora do quadro`);
if (p.tone !== undefined && !TONES.includes(p.tone)) errors.push(`props[${i}]: tone inválido`); if (p.tone !== undefined && !TONES.includes(p.tone)) errors.push(`props[${i}]: tone inválido`);
} }
for (const [i, t] of (s.texts ?? []).entries()) { if (s.hud !== undefined) errors.push(...validateHud(s.hud));
if (!["onomatopoeia", "tag", "counter", "big"].includes(t.kind)) errors.push(`texts[${i}]: kind inválido`); for (const [i, t] of (s.texts ?? []).entries()) errors.push(...validateText(t, i));
if (typeof t.text !== "string" || !t.text.trim()) errors.push(`texts[${i}]: texto vazio`); if (s.audioEnv !== undefined && (!finite(s.audioEnv.fps) || !Array.isArray(s.audioEnv.values) || s.audioEnv.values.length > 36000)) errors.push("audioEnv: { fps, values[] } (até 36 mil valores)");
if (!frac(t.x) || !frac(t.y)) errors.push(`texts[${i}]: x/y fora do quadro`);
}
for (const [i, w] of (s.words ?? []).entries()) { for (const [i, w] of (s.words ?? []).entries()) {
if (typeof w.text !== "string" || !finite(w.startS) || !finite(w.endS) || w.endS < w.startS) errors.push(`words[${i}]: inválida`); if (typeof w.text !== "string" || !finite(w.startS) || !finite(w.endS) || w.endS < w.startS) errors.push(`words[${i}]: inválida`);
} }
return errors; return errors;
} }
const str = (v: unknown): v is string => typeof v === "string";
function validateHud(h: Hud): string[] {
const errors: string[] = [];
if (!h || typeof h !== "object") return ["hud precisa ser um objeto"];
if (!str(h.badge) || !str(h.label)) errors.push("hud: badge e label são texto");
for (const k of ["clock", "place", "value", "valueLabel", "note"] as const) if (h[k] !== undefined && !str(h[k])) errors.push(`hud.${k}: texto`);
if (h.clockMinutesPerSecond !== undefined && !finite(h.clockMinutesPerSecond)) errors.push("hud.clockMinutesPerSecond: número");
if (h.valueTone !== undefined && !TONES.includes(h.valueTone)) errors.push(`hud.valueTone: ${TONES.join(", ")}`);
return errors;
}
/** "97", 97 ou "97,5" → número (NaN se não for). */
export const numberOf = (v: unknown) => (typeof v === "number" ? v : typeof v === "string" && v.trim() ? Number(v.replace(/%$/, "").replace(",", ".")) : NaN);
const OPTIONAL_TEXT: TextKind[] = ["table", "stat", "checklist"];
function validateText(t: TextItem, i: number): string[] {
const errors: string[] = [];
const at = `texts[${i}]`;
if (!t || typeof t !== "object") return [`${at}: precisa ser um objeto`];
if (!TEXT_KINDS.includes(t.kind)) errors.push(`${at}: kind inválido (${TEXT_KINDS.join(", ")})`);
// Tabela e lista podem ir sem título e o stat sem rótulo (só o número); os demais precisam de texto.
if (!str(t.text) || (!t.text.trim() && !OPTIONAL_TEXT.includes(t.kind))) errors.push(`${at}: texto vazio`);
if (!frac(t.x) || !frac(t.y)) errors.push(`${at}: x/y fora do quadro`);
if (t.tone !== undefined && !TONES.includes(t.tone)) errors.push(`${at}: tone inválido`);
if (t.value !== undefined && !str(t.value) && !finite(t.value)) errors.push(`${at}: value é texto ou número`);
if (t.size !== undefined && !(finite(t.size) && t.size >= 0.3 && t.size <= 2)) errors.push(`${at}: size entre 0,3 e 2`);
if (t.lines !== undefined && !(Array.isArray(t.lines) && t.lines.length <= 3 && t.lines.every(str))) errors.push(`${at}: lines = até 3 textos`);
if (t.kind === "stat" && (t.value === undefined || !String(t.value).trim())) errors.push(`${at}: stat precisa de value`);
if (t.kind === "checklist" || t.kind === "table") {
if (!Array.isArray(t.items) || !t.items.length || t.items.length > 8) errors.push(`${at}: items com 1 a 8 linhas`);
else for (const [j, r] of t.items.entries()) {
if (!r || !str(r.text) || !r.text.trim()) errors.push(`${at}.items[${j}]: texto vazio`);
else if (r.state !== undefined && !CHECK_STATES.includes(r.state)) errors.push(`${at}.items[${j}]: state (${CHECK_STATES.join(", ")})`);
else if (r.value !== undefined && !str(r.value)) errors.push(`${at}.items[${j}]: value é texto`);
}
}
if (t.highlight !== undefined && !(Number.isInteger(t.highlight) && t.highlight >= 0 && t.highlight < (t.items?.length ?? 0))) errors.push(`${at}: highlight fora das linhas`);
if (t.stepS !== undefined && !(finite(t.stepS) && t.stepS >= 0 && t.stepS <= 5)) errors.push(`${at}: stepS entre 0 e 5`);
if (t.kind === "progress" && !(numberOf(t.value) >= 0 && numberOf(t.value) <= 100)) errors.push(`${at}: progress precisa de value entre 0 e 100`);
if (t.kind === "grid") {
const total = t.total ?? NaN;
if (!(Number.isInteger(total) && total >= 1 && total <= 40)) errors.push(`${at}: grid precisa de total inteiro entre 1 e 40`);
else if (!(Number.isInteger(numberOf(t.value)) && numberOf(t.value) >= 0 && numberOf(t.value) <= total)) errors.push(`${at}: grid precisa de value inteiro entre 0 e total`);
}
return errors;
}
/** Número de quadros do trecho (arredonda para cima: o vídeo nunca fica mais curto que o áudio). */ /** Número de quadros do trecho (arredonda para cima: o vídeo nunca fica mais curto que o áudio). */
export const frameCount = (spec: Pick<ShotSpec, "durationS" | "fps">) => Math.max(1, Math.ceil(spec.durationS * spec.fps)); export const frameCount = (spec: Pick<ShotSpec, "durationS" | "fps">) => Math.max(1, Math.ceil(spec.durationS * spec.fps));
+7
View File
@@ -4,6 +4,12 @@ import { FONT_CAPTION, FONT_LABEL } from "./colors";
export * from "./colors"; export * from "./colors";
/**
* Texto de apoio do grafismo (HUD, rótulos espaçados, listas, linhas do cartão de nome): Barlow Semi Condensed Bold
* (OFL-1.1, licença em assets/fonts/BarlowSemiCondensed-Bold.OFL.txt). Condensada e legível em tamanho pequeno.
*/
export const FONT_TEXT = "CartoonBarlow";
let loaded = false; let loaded = false;
/** Carrega as fontes de assets/fonts antes do primeiro quadro (o render espera). */ /** Carrega as fontes de assets/fonts antes do primeiro quadro (o render espera). */
export function loadFonts(): void { export function loadFonts(): void {
@@ -13,6 +19,7 @@ export function loadFonts(): void {
const faces = [ const faces = [
new FontFace(FONT_CAPTION, `url(${staticFile("fonts/Anton-Regular.ttf")})`), new FontFace(FONT_CAPTION, `url(${staticFile("fonts/Anton-Regular.ttf")})`),
new FontFace(FONT_LABEL, `url(${staticFile("fonts/BebasNeue-Regular.ttf")})`), new FontFace(FONT_LABEL, `url(${staticFile("fonts/BebasNeue-Regular.ttf")})`),
new FontFace(FONT_TEXT, `url(${staticFile("fonts/BarlowSemiCondensed-Bold.ttf")})`),
]; ];
Promise.all(faces.map((f) => f.load().then((ok) => document.fonts.add(ok)))) Promise.all(faces.map((f) => f.load().then((ok) => document.fonts.add(ok))))
.then(() => continueRender(handle)) .then(() => continueRender(handle))
+35
View File
@@ -0,0 +1,35 @@
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { GRIP, HAND_SHAPES, TWO_HANDED, handPlacement, wristForHold } from "../src/hands";
describe("biblioteca de mãos", () => {
it("o pulso acompanha o eixo do antebraço: a forma gira em torno do centro do pulso", () => {
for (const shape of HAND_SHAPES) {
for (const fore of [0, 45, 120, -60]) {
for (const s of [1, -1] as const) {
const p = handPlacement(shape, 30, 40, fore, s, 0.6);
// O centro do pulso do desenho cai exatamente no pulso da tela, em qualquer giro e espelho.
const w = p.map(p.def.wrist[0], p.def.wrist[1]);
assert.ok(Math.abs(w.x - 30) < 1e-9 && Math.abs(w.y - 40) < 1e-9, `${shape} ${fore} ${s}`);
}
}
}
});
it("formas em pé giram pela diferença entre o antebraço e o ângulo do desenho (espelhadas do outro lado)", () => {
assert.equal(handPlacement("thumbs_up", 0, 0, 135, 1, 1).rot, 0);
assert.equal(handPlacement("thumbs_up", 0, 0, -135, -1, 1).rot, 0);
assert.equal(handPlacement("grip", 0, 0, 75, 1, 1).rot, 30);
});
it("pegada de borda: o pulso calculado põe a borda do objeto no ponto pedido", () => {
const w = wristForHold("pinch_edge", 120, 80, 48, 1, 0.62);
const hold = handPlacement("pinch_edge", w.x, w.y, 48, 1, 0.62).hold!;
assert.ok(Math.abs(hold.x - 120) < 1e-9 && Math.abs(hold.y - 80) < 1e-9);
});
it("livro e tábua vão nas duas mãos; martelo, ramo e régua têm cabo em pé no punho", () => {
assert.ok(TWO_HANDED.includes("book") && TWO_HANDED.includes("tablet") && !TWO_HANDED.includes("hammer"));
for (const id of ["hammer", "olive", "ruler"] as const) assert.ok(GRIP[id], id);
});
});
+50
View File
@@ -0,0 +1,50 @@
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { armGeometry, armLayer } from "../src/limbs";
import { ACTIONS, evaluate } from "../src/motion";
import { POSE_PRESETS, bodyOf } from "../src/rig";
const layers = (pose: string, patch?: Parameters<typeof bodyOf>[1], holds = false) => {
const b = bodyOf(pose, patch);
return [armLayer(b, -1), armLayer(b, 1, { holds })];
};
describe("profundidade dos braços (personagem de frente)", () => {
it("braço ao lado do corpo, acenando ou apontando para fora fica 'side'", () => {
for (const pose of ["stand", "wave", "arms_up", "celebrate", "point", "reach", "lean_in"]) assert.deepEqual(layers(pose), ["side", "side"], pose);
});
it("antebraço na frente do peito fica 'front': cruzar os braços, segurar, mão na cintura, apontar para o outro lado", () => {
assert.deepEqual(layers("cross_arms"), ["front", "front"]);
assert.deepEqual(layers("hands_on_hips"), ["front", "front"]);
assert.equal(layers("hold")[1], "front");
assert.equal(layers("point", { armR: { raise: 40, bend: 120 } })[1], "front");
});
it("mão na altura do pescoço/rosto fica 'face' (por cima da cabeça e da barba)", () => {
// Pensar (queixo), tapar a boca e mão na testa: a mão chega ao rosto.
for (const pose of ["think", "cover_mouth", "facepalm"]) assert.equal(layers(pose)[1], "face", pose);
assert.equal(layers("stand", { armR: { raise: 10, bend: 175 } })[1], "face");
// Mesmo segurando objeto: no rosto, a mão vai por cima da cabeça.
assert.equal(layers("cover_mouth", undefined, true)[1], "face");
});
it("objeto na mão deixa o braço na frente do corpo; o lado esquerdo espelha o direito", () => {
assert.equal(layers("stand", undefined, true)[1], "front");
const b = bodyOf("cross_arms");
const [l, r] = [armGeometry(b, -1), armGeometry(b, 1)];
assert.ok(Math.abs(l.hand.x - 100 + (r.hand.x - 100)) < 1e-9 && Math.abs(l.hand.y - r.hand.y) < 1e-9);
});
it("toda pose pronta e todo quadro de toda ação têm camada válida (função pura, sem relógio)", () => {
const valid = new Set(["side", "front", "face"]);
for (const pose of Object.keys(POSE_PRESETS)) for (const s of [-1, 1] as const) assert.ok(valid.has(armLayer(bodyOf(pose), s)), pose);
for (const action of ACTIONS) {
for (let t = 0; t <= 2; t += 0.25) {
const st = evaluate({ x: 0.5, timeline: [{ do: action, at: 0, dur: 2, text: "oi" }] }, t, 2, 1);
for (const s of [-1, 1] as const) assert.ok(valid.has(armLayer(st.body, s)), `${action} ${t}`);
}
}
assert.equal(armLayer(bodyOf("wave"), 1), armLayer(bodyOf("wave"), 1));
});
});
+79
View File
@@ -0,0 +1,79 @@
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { visemeAt, speak } from "../src/lipsync";
import { evaluate, startOf, validateTimeline } from "../src/motion";
import { EXPRESSION_NAMES, blendFace, faceOf } from "../src/rig";
const words = [
{ text: "Mamãe", startS: 0.2, endS: 0.7 },
{ text: "não", startS: 0.8, endS: 1.2 },
{ text: "ouviu", startS: 1.3, endS: 1.8 },
];
describe("rig: expressões como parâmetros", () => {
it("toda expressão pronta vira parâmetros válidos e se mistura com outra", () => {
for (const name of EXPRESSION_NAMES) assert.ok(Number.isFinite(faceOf(name).smile), name);
const half = blendFace(faceOf("sad"), faceOf("happy"), 0.5);
assert.ok(half.smile > faceOf("sad").smile && half.smile < faceOf("happy").smile);
});
it("ajuste fino por cima de uma expressão", () => {
assert.equal(faceOf("neutral", { smile: 0.8, browL: { y: -6 } }).browL.y, -6);
});
});
describe("linha do tempo", () => {
it("cue = palavra falada; atP = fração do trecho", () => {
assert.equal(startOf({ do: "nod", cue: "nao" }, 4, words), 0.8);
assert.equal(startOf({ do: "nod", atP: 0.5 }, 4, words), 2);
assert.equal(startOf({ do: "nod", cue: "inexistente", at: 1 }, 4, words), 1);
});
it("andar chega ao destino e vira para o lado certo; é determinístico", () => {
const actor = { x: 0.7, timeline: [{ do: "walk" as const, at: 0, to: 0.3, dur: 1 }] };
const end = evaluate(actor, 2, 4);
assert.ok(Math.abs(end.x - 0.3) < 1e-9);
assert.equal(end.flip, true);
assert.deepEqual(evaluate(actor, 0.5, 4), evaluate(actor, 0.5, 4));
});
it("trocar expressão é suave e permanente", () => {
const actor = { x: 0.5, timeline: [{ do: "express" as const, at: 1, expression: "happy", dur: 0.4 }] };
const mid = evaluate(actor, 1.2, 4).face.smile;
assert.ok(mid > faceOf("neutral").smile && mid < faceOf("happy").smile);
assert.ok(Math.abs(evaluate(actor, 3, 4).face.smile - faceOf("happy").smile) < 1e-9);
});
it("pular sobe e volta ao chão", () => {
const actor = { x: 0.5, timeline: [{ do: "jump" as const, at: 0, dur: 1 }] };
assert.ok(evaluate(actor, 0.5, 4).dy < -0.05);
assert.equal(evaluate(actor, 2, 4).dy, 0);
});
it("valida a linha do tempo", () => {
assert.deepEqual(validateTimeline([{ do: "walk", to: 0.3 }]), []);
assert.match(validateTimeline([{ do: "voar" }]).join(), /do:/);
});
});
describe("fala: boca pelas letras, expressão mantida", () => {
it("m fecha, a abre, o arredonda; fora das palavras fica fechada", () => {
assert.equal(visemeAt(words, 0.21).open, 0); // "M" do começo
assert.ok(visemeAt([{ text: "aaa", startS: 0, endS: 1 }], 0.5).open > 0.7);
assert.ok(visemeAt([{ text: "oo", startS: 0, endS: 1 }], 0.5).round > 0.6);
assert.equal(visemeAt(words, 3).open, 0);
});
it("falando bravo continua bravo (sobrancelhas e cantos da boca)", () => {
const angry = faceOf("angry");
const talking = speak(angry, visemeAt([{ text: "aaa", startS: 0, endS: 1 }], 0.5));
assert.equal(talking.browL.tilt, angry.browL.tilt);
assert.equal(talking.smile, angry.smile);
assert.ok(talking.mouthOpen > 0.5);
});
it("a ação falar vai da palavra de início até o fim da palavra final", () => {
const actor = { x: 0.5, timeline: [{ do: "talk" as const, cue: "mamae", cueEnd: "ouviu" }] };
assert.ok(evaluate(actor, 0.45, 4, 1, { words }).face.mouthOpen > 0.2);
assert.ok(evaluate(actor, 2.5, 4, 1, { words }).face.mouthOpen < 0.05);
});
it("com o volume do áudio, a boca fecha na pausa", () => {
const env = { fps: 10, values: Array.from({ length: 20 }, (_, i) => (i === 5 ? 0 : 0.9)) };
const loud = visemeAt([{ text: "aaaaaaaaaa", startS: 0, endS: 2 }], 0.25, env).open;
const pause = visemeAt([{ text: "aaaaaaaaaa", startS: 0, endS: 2 }], 0.55, env).open;
assert.ok(loud > 0.5 && pause < 0.2);
});
});
+37
View File
@@ -0,0 +1,37 @@
import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { SAMPLE } from "../src/sample";
import { layoutPlace, resolveLight } from "../src/places";
import { validateSpec, type ShotSpec } from "../src/spec";
const place = (elements: NonNullable<ShotSpec["place"]>["elements"], indoor = true): ShotSpec =>
({ ...SAMPLE, scene: { kind: "place" }, palette: "night", place: { ground: "floor", indoor, elements } }) as ShotSpec;
describe("lugar por peças: luz e regras de posição", () => {
it("lightSource é opcional e conferido; specs antigos continuam válidos", () => {
assert.deepEqual(validateSpec({ ...SAMPLE, lightSource: { kind: "window", x: 0.1, y: 0.3 } }), []);
assert.match(validateSpec({ ...SAMPLE, lightSource: { kind: "lanterna", x: 0.1 } }).join(), /lightSource/);
assert.match(validateSpec({ ...SAMPLE, lightSource: { kind: "lamp", x: 3 } }).join(), /lightSource/);
assert.deepEqual(validateSpec({ ...SAMPLE, light: "spot" }), []);
});
it("peças novas existem; janela/quadro grudam na parede e a luminária de mesa sobe na escrivaninha", () => {
const spec = place([{ kind: "window", x: 0.2, z: 0.1 }, { kind: "desk", x: 0.6, z: 0.4 }, { kind: "desklamp", x: 0.7, z: 0.4 }, { kind: "frame", x: 0.5 }]);
assert.deepEqual(validateSpec(spec), []);
const { items, horizon } = layoutPlace(spec);
const by = (k: string) => items.find((it) => it.e.kind === k)!;
assert.equal(by("window").y, horizon);
assert.equal(by("frame").zEff, 1);
assert.ok(by("desklamp").y < by("desk").y - 200, "a luminária fica em cima do tampo");
assert.ok(items.indexOf(by("desklamp")) > items.indexOf(by("desk")), "e é desenhada depois da mesa");
});
it("fonte de luz: explícita > pendente > janela; 'none' desliga", () => {
const spec = place([{ kind: "pendant", x: 0.5, z: 0.5 }, { kind: "window", x: 0.15 }]);
assert.equal(resolveLight(spec, undefined)?.kind, "lamp");
assert.equal(resolveLight(place([{ kind: "window", x: 0.15 }]), undefined)?.kind, "window");
assert.equal(resolveLight({ ...spec, lightSource: { kind: "sun", x: 0.2 } }, undefined)?.kind, "sun");
assert.equal(resolveLight(spec, "none"), null);
assert.equal(resolveLight(place([]), "spot")?.kind, "lamp");
});
});
+59 -1
View File
@@ -1,6 +1,6 @@
import assert from "node:assert/strict"; import assert from "node:assert/strict";
import { describe, it } from "node:test"; import { describe, it } from "node:test";
import { captionChunks } from "../src/overlays"; import { captionChunks, countUp, hudClock, hudValueTone } from "../src/overlays";
import { SAMPLE } from "../src/sample"; import { SAMPLE } from "../src/sample";
import { frameCount, validateSpec } from "../src/spec"; import { frameCount, validateSpec } from "../src/spec";
@@ -31,3 +31,61 @@ describe("spec do Cartoon", () => {
assert.deepEqual(chunks, ["Num apagão,", "a casa acesa", "chama atenção."]); assert.deepEqual(chunks, ["Num apagão,", "a casa acesa", "chama atenção."]);
}); });
}); });
describe("grafismo do Cartoon: cartelas, cartão de nome e HUD", () => {
const ok = (texts: unknown[], extra: Record<string, unknown> = {}) => validateSpec({ ...SAMPLE, ...extra, texts });
const base = { x: 0.5, y: 0.4, atS: 0.2 };
it("aceita os kinds novos bem formados (e o stat/lista sem título)", () => {
assert.deepEqual(ok([
{ kind: "namecard", text: "Seu Amaro", lines: ["Roupeiro há 38 anos", "7 meses sem salário"], ...base },
{ kind: "stat", text: "No caixa", value: "R$ 0", tone: "danger", panel: true, ...base },
{ kind: "stat", text: "", value: 61, ...base },
{ kind: "counter", text: "Na fila", value: "297", ...base },
{ kind: "checklist", text: "", size: 0.5, items: [{ text: "Funcionários", state: "checked" }, { text: "Elenco", state: "crossed" }, { text: "Registro" }], ...base },
{ kind: "table", text: "", highlight: 1, items: [{ text: "Atlético", value: "31" }, { text: "Vila Nova", value: "4" }], ...base },
{ kind: "progress", text: "Talento", value: 97, ...base },
{ kind: "progress", text: "Talento", value: "97%", ...base },
{ kind: "grid", text: "Com contrato", value: 4, total: 18, ...base },
]), []);
});
it("recusa kind desconhecido, lista vazia, estado, destaque, porcentagem e grade inválidos", () => {
const errors = ok([
{ kind: "slide", text: "x", ...base },
{ kind: "checklist", text: "", items: [], ...base },
{ kind: "checklist", text: "", items: [{ text: "a", state: "talvez" }], ...base },
{ kind: "table", text: "", items: [{ text: "a", value: "1" }], highlight: 3, ...base },
{ kind: "progress", text: "Talento", value: 140, ...base },
{ kind: "grid", text: "Com contrato", value: 20, total: 18, ...base },
{ kind: "stat", text: "No caixa", ...base },
{ kind: "namecard", text: "", ...base },
{ kind: "grid", text: "g", value: 1, total: 4, size: 9, ...base },
]).join(" | ");
for (const re of [/texts\[0\]: kind/, /texts\[1\]: items/, /texts\[2\]\.items\[0\]: state/, /texts\[3\]: highlight/, /texts\[4\]: progress/,
/texts\[5\]: grid/, /texts\[6\]: stat precisa de value/, /texts\[7\]: texto vazio/, /texts\[8\]: size/]) assert.match(errors, re);
});
it("HUD: campos antigos continuam valendo; novos são opcionais e conferidos", () => {
assert.deepEqual(validateSpec({ ...SAMPLE, hud: { badge: "DIA 3", label: "Vila Nova" } }), []);
assert.deepEqual(validateSpec({ ...SAMPLE, hud: { badge: "Dia 1", label: "x", clock: "10:06", clockMinutesPerSecond: 1, place: "Vila Nova (MG)",
value: "R$ 0,00", valueLabel: "Caixa", valueTone: "danger", note: "Estreia em 30 dias" } }), []);
assert.match(validateSpec({ ...SAMPLE, hud: { badge: "Dia 1", label: "x", valueTone: "roxo" } }).join(), /hud.valueTone/);
assert.match(validateSpec({ ...SAMPLE, hud: { badge: 3, label: "x" } }).join(), /hud: badge/);
});
it("número contando, hora andando e cor do valor do HUD são funções puras", () => {
assert.equal(countUp("R$ 134.273", 0.5), "R$ 67.137");
assert.equal(countUp("R$ 134.273", 1), "R$ 134.273");
assert.equal(countUp("-R$ 47.312.904", 0), "-R$ 0");
assert.equal(countUp("R$ 0", 0.3), "R$ 0");
assert.equal(countUp("Vila Nova", 0.3), "Vila Nova");
assert.equal(hudClock("10:06", 2.5, 2), "10:11");
assert.equal(hudClock("23:59", 1, 2), "00:01");
assert.equal(hudClock("10:06", 9), "10:06");
assert.equal(hudValueTone("R$ 0,00"), "danger");
assert.equal(hudValueTone("-12"), "danger");
assert.equal(hudValueTone("R$ 800"), undefined);
assert.equal(hudValueTone("R$ 800", "info"), "info");
});
});
+40 -6
View File
@@ -2,7 +2,7 @@
Serviço local do CenaForge (`127.0.0.1:4520`, faixa 4500–4599) que assiste lives da **Twitch, YouTube e Kick**, Serviço local do CenaForge (`127.0.0.1:4520`, faixa 4500–4599) que assiste lives da **Twitch, YouTube e Kick**,
lê o **chat em tempo real**, transcreve a fala com o **Whisper** (serviço de voz, 4510), pede a uma **IA pela CLI** lê o **chat em tempo real**, transcreve a fala com o **Whisper** (serviço de voz, 4510), pede a uma **IA pela CLI**
(Codex/GPT por padrão, ou Claude) que confirme o momento e gera **cortes com legenda queimada**: verticais 1080×1920 (Codex/GPT por padrão, Claude ou Gemini) que confirme o momento e gera **cortes com legenda queimada**: verticais 1080×1920
(Shorts/Reels/TikTok, padrão) ou horizontais 1920×1080 (YouTube "tela grande", mostrando o próprio jogo). (Shorts/Reels/TikTok, padrão) ou horizontais 1920×1080 (YouTube "tela grande", mostrando o próprio jogo).
O painel (`/clipper`) mostra a fila para aprovar. As contas que recebem os cortes de cada canal são ligadas na O painel (`/clipper`) mostra a fila para aprovar. As contas que recebem os cortes de cada canal são ligadas na
página **Contas**, como as histórias. página **Contas**, como as histórias.
@@ -60,6 +60,16 @@ chegar (`wall_end`), então a pausa do Streamlink ao filtrar anúncio da Twitch
teto de 45 s além dele (passou disso, mostra "aguardando o bloco"); "Agora na live" mostra a contagem para o próximo teto de 45 s além dele (passou disso, mostra "aguardando o bloco"); "Agora na live" mostra a contagem para o próximo
resumo da varredura, com o intervalo vindo de `GET /v1/status` → `judge.options.scanIntervalS`. resumo da varredura, com o intervalo vindo de `GET /v1/status` → `judge.options.scanIntervalS`.
**Parar é parar (18/11/2026).** `POST /v1/sessions/{id}/stop` à mão pausa o monitor da fonte
(`channels.monitor_paused_at` + `monitor_paused_session`): o monitor não abre sessão nova enquanto a live continuar
no ar. Religa com `PATCH /v1/channels/{id}` `{monitor: true}`, gravando pelo link (`POST /v1/sessions`) ou retomando
a sessão pelo painel. `{"pauseMonitor": false}` no corpo do stop mantém o monitor ligado. Queda de live (captura cai
sozinha) continua retomando **na mesma sessão** (`keep_live`), sem passar pela pausa.
**Idioma por fonte e por sessão.** `language` em `channels` e `sessions` (`pt-BR`, `en-US`, `es-419`; vazio = `CLIPPER_LANGUAGE`).
A sessão herda o da fonte; a transcrição manda esse idioma ao Whisper e, fora de pt-BR, o contexto do editor e da
varredura ganha a linha "Idioma de saída: …" (título, legenda e hashtags no idioma do público).
## Contexto do jogo ## Contexto do jogo
- Categoria da plataforma (Streamlink `--json`, `metadata.category`) no início e a cada 10 min (troca registrada em - Categoria da plataforma (Streamlink `--json`, `metadata.category`) no início e a cada 10 min (troca registrada em
@@ -68,6 +78,17 @@ resumo da varredura, com o intervalo vindo de `GET /v1/status` → `judge.option
- **Perfil do jogo** pesquisado na web pela CLI (`codex --search`), guardado por jogo (tabela `games`): resumo, - **Perfil do jogo** pesquisado na web pela CLI (`codex --search`), guardado por jogo (tabela `games`): resumo,
mecânicas, o que rende corte, o que não rende, gírias, novidades, fontes. Medido: ~15–35 s por jogo. mecânicas, o que rende corte, o que não rende, gírias, novidades, fontes. Medido: ~15–35 s por jogo.
- Correção manual: `PUT /v1/sessions/{id}/game` (trava a troca automática). - Correção manual: `PUT /v1/sessions/{id}/game` (trava a troca automática).
- **Dois idiomas** (v12, `doc/clipador/JOGOS.md`): a pesquisa é feita e guardada **em inglês** (`profile_ai_json`,
é o que vai nos prompts) e traduzida para **português** (`profile_json`, o que o painel mostra). Editar à mão
(`PUT /v1/games/{id}?lang=pt|en`) ou pedir à IA (`refine`, resposta em português) atualiza um e traduz o outro;
jogo antigo ganha a versão em inglês com `POST /v1/games/{id}/translate`.
- O perfil tem **missões** (só se a lista for pública; nunca inventadas) com **gatilhos de fim** e sinais gerais de
fim de missão (`end_triggers`). O contexto leva até 25 missões (~1500 caracteres) e manda terminar o corte de
missão logo depois do gatilho. **Outros nomes** (`aliases`): categoria "Grand Theft Auto VI" e tela "GTA 6" caem
no mesmo perfil.
- Cadastrar pelo painel: `POST /v1/games {name, notes?}` (pesquisa em segundo plano; 409 se já existe, inclusive por
outro nome) · apagar: `DELETE /v1/games/{id}`. **Sementes** em `app/seeds/games/*.json` (ex.: GTA VI) entram na
subida só se o jogo ainda não existe; nunca sobrescrevem a sua edição.
## Configuração do corte (layout, câmera, legenda) ## Configuração do corte (layout, câmera, legenda)
@@ -348,14 +369,15 @@ Validação forte (`editor.validate_project`): limites de duração (3–180 s)
tentativa em 5 min. tentativa em 5 min.
- **API**: `GET /v1/sessions/{id}/face?from=&to=` (série, `signal`, picos, câmera, progresso) e `POST …/face/reset`. - **API**: `GET /v1/sessions/{id}/face?from=&to=` (série, `signal`, picos, câmera, progresso) e `POST …/face/reset`.
## Juiz de IA (pela CLI, sem chave de API) ## Juiz de IA (pela CLI)
Usa as CLIs já logadas no PC — as mesmas da página Agente: Usa as CLIs do PC — as mesmas da página Agente:
| Provedor | Comando | Modelo padrão | Lista de modelos | | Provedor | Comando | Modelo padrão | Lista de modelos |
|---|---|---|---| |---|---|---|---|
| `codex` (padrão) | `codex exec --ephemeral --sandbox read-only --output-schema … -o … -` | `gpt-6-luna` (rápido e barato) | `~/.codex/models_cache.json` (só `visibility: list`) | | `codex` (padrão) | `codex exec --ephemeral --sandbox read-only --output-schema … -o … -` | `gpt-6-luna` (rápido e barato) | `~/.codex/models_cache.json` (só `visibility: list`) |
| `claude` | `claude -p --json-schema … --no-session-persistence` (imagens pela ferramenta Read; web por WebSearch) | `haiku` | `haiku`, `sonnet`, `opus` | | `claude` | `claude -p --json-schema … --no-session-persistence` (imagens pela ferramenta Read; web por WebSearch) | `haiku` | `haiku`, `sonnet`, `opus` |
| `gemini` | `gemini -p … -o json --approval-mode plan --skip-trust -m …` (schema no prompt; imagens por `@arquivo`) | `gemini-3.5-flash` | `gemini-3.5-flash`, `gemini-3.1-flash-lite`, `gemini-2.5-pro` |
| `off` | — | — | só a heurística | | `off` | — | — | só a heurística |
Codex: imagens com `-i` (uma por flag, antes de `-`), busca na web com `--search` (opção global, antes de `exec`). Codex: imagens com `-i` (uma por flag, antes de `-`), busca na web com `--search` (opção global, antes de `exec`).
@@ -364,6 +386,18 @@ Provedor, modelo do editor, **modelo do analista** (`analystModel`, vazio = o me
reiniciar. O `.env` só dá os valores iniciais. Medido (16/11/2026): `gpt-6-luna` respondeu em ~7 s por candidato. reiniciar. O `.env` só dá os valores iniciais. Medido (16/11/2026): `gpt-6-luna` respondeu em ~7 s por candidato.
Falha do juiz não perde o momento: o corte segue pela heurística e o erro fica em `judge.error`. Falha do juiz não perde o momento: o corte segue pela heurística e o erro fica em `judge.error`.
**Gemini, login/chave e IA reserva (18/11/2026)** — contrato em [`doc/ia.md`](../doc/ia.md). O painel
(Configurações → IA) grava `data/ai/settings.json` (IAs ligadas, `authMode` `oauth`/`apiKey`, `order`, `fallback`) e
`data/ai/vault.bin` (chaves, DPAPI do usuário); o Clipador só lê (`app/ai_settings.py`, relê pelo mtime) e monta o
`env` de cada chamada (a chave só vale para aquela chamada). Se a IA escolhida falhar por **indisponibilidade**
(cota, 429/529/503, login/chave, rede, CLI ausente, tempo esgotado — `judge.is_availability_error`), a próxima da
`order` ligada, com CLI e com chave tenta com o **modelo padrão dela**, e a que caiu fica em pausa `cooldownMin` (em
memória). Erro de conteúdo (JSON inválido, campo faltando) não troca. `judge.model` do corte = quem de fato
respondeu; `GET /v1/judge` traz `fallback.chain`, `pauses` e `unavailableReason`. Gemini: sem `--output-schema`, o
JSON é extraído da resposta; o corpo vai pelo stdin e o `-p` leva só a instrução curta e os `@frame-NN.jpg`; roda
numa pasta temporária FORA do repo (o `@arquivo` respeita o .gitignore, que ignora `data/`), com as imagens copiadas.
OAuth do Gemini para conta pessoal foi encerrado pelo Google: use chave de API do AI Studio.
## Instalação e subida ## Instalação e subida
- `setup.bat` cria `clipper/.venv` (Python 3.12 via uv), instala `requirements.txt` (Streamlink 8.6.3) e gera - `setup.bat` cria `clipper/.venv` (Python 3.12 via uv), instala `requirements.txt` (Streamlink 8.6.3) e gera
@@ -386,7 +420,7 @@ Precisa do FFmpeg com `libass` (legenda) — o build `essentials` do gyan.dev te
| `CLIPPER_SEGMENT_S` | 30 | tamanho do bloco gravado | | `CLIPPER_SEGMENT_S` | 30 | tamanho do bloco gravado |
| `CLIPPER_POLL_S` | 60 | intervalo para checar se um canal monitorado entrou ao vivo | | `CLIPPER_POLL_S` | 60 | intervalo para checar se um canal monitorado entrou ao vivo |
| `CLIPPER_KEEP_HOURS` | 6 | apaga blocos mais velhos que isto se nenhum corte pendente precisar (0 = nunca) | | `CLIPPER_KEEP_HOURS` | 6 | apaga blocos mais velhos que isto se nenhum corte pendente precisar (0 = nunca) |
| `CLIPPER_LANGUAGE` | `pt-BR` | idioma da transcrição | | `CLIPPER_LANGUAGE` | `pt-BR` | idioma padrão da transcrição e dos textos da IA (cada fonte/sessão pode ter o seu: `language`) |
| `CLIPPER_ENCODER` | `auto` | `auto` (NVENC se houver) · `libx264` · `h264_nvenc` | | `CLIPPER_ENCODER` | `auto` | `auto` (NVENC se houver) · `libx264` · `h264_nvenc` |
| `CLIPPER_JUDGE_PROVIDER` / `_MODEL` / `_MIN_SCORE` | `codex` / (padrão) / 6 | valores iniciais do juiz | | `CLIPPER_JUDGE_PROVIDER` / `_MODEL` / `_MIN_SCORE` | `codex` / (padrão) / 6 | valores iniciais do juiz |
| `CLIPPER_DATA_DIR` | `data/clipper` | banco, blocos gravados, modelos do rastreio e arquivos do juiz; para isolar uma instância de teste (relativo ao repo ou absoluto, **dentro** do repo) | | `CLIPPER_DATA_DIR` | `data/clipper` | banco, blocos gravados, modelos do rastreio e arquivos do juiz; para isolar uma instância de teste (relativo ao repo ou absoluto, **dentro** do repo) |
@@ -410,8 +444,8 @@ chave `clipper-<sessão>-<bloco>`; num banco novo as sessões recomeçam do 1 e
| `GET /v1/sessions/{id}/face?from=&to=` · `POST …/face/reset` | série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal`) e picos; refazer o rastreio | | `GET /v1/sessions/{id}/face?from=&to=` · `POST …/face/reset` | série por segundo do rosto (cx/cy/size no quadro inteiro, expressões, `signal`) e picos; refazer o rastreio |
| `PUT /v1/sessions/{id}/game` · `GET /v1/games` · `POST /v1/games/{id}/research` · `PUT /v1/games/{id}` · `POST /v1/games/{id}/refine` · `DELETE /v1/games/{id}/notes/{n}` | jogo da sessão, perfis pesquisados, edição à mão e pedidos à IA | | `PUT /v1/sessions/{id}/game` · `GET /v1/games` · `POST /v1/games/{id}/research` · `PUT /v1/games/{id}` · `POST /v1/games/{id}/refine` · `DELETE /v1/games/{id}/notes/{n}` | jogo da sessão, perfis pesquisados, edição à mão e pedidos à IA |
| `GET /v1/emotes?channel=twitch-<login>` | emotes do canal, usos e peso aprendido | | `GET /v1/emotes?channel=twitch-<login>` | emotes do canal, usos e peso aprendido |
| `GET/POST /v1/channels` · `PATCH/DELETE /v1/channels/{id}` · `POST /v1/channels/{id}/check` | canais (`monitor` grava sozinho ao entrar ao vivo; `authorized` = streamer autorizou) | | `GET/POST /v1/channels` · `PATCH/DELETE /v1/channels/{id}` · `POST /v1/channels/{id}/check` | canais (`monitor` grava sozinho ao entrar ao vivo; `authorized` = streamer autorizou; `language`; `monitorPausedAt`/`monitorPausedBySession` = monitor pausado porque você parou uma sessão; `PATCH {monitor: true}` religa) |
| `GET/POST /v1/sessions` · `GET/DELETE /v1/sessions/{id}` · `POST …/stop` | gravar live ou processar VOD pelo link; cada sessão traz `capture` (resolução, qps, codec e taxa gravados de fato; `null` = sessão antiga) | | `GET/POST /v1/sessions` · `GET/DELETE /v1/sessions/{id}` · `POST …/stop` `{pauseMonitor?: true}` | gravar live ou processar VOD pelo link (`language` opcional; herda o da fonte); parar à mão pausa o monitor da fonte; cada sessão traz `language` e `capture` (resolução, qps, codec e taxa gravados de fato; `null` = sessão antiga) |
| `GET /v1/sessions/{id}/timeline` | mensagens/s, razão do chat e volume por segundo | | `GET /v1/sessions/{id}/timeline` | mensagens/s, razão do chat e volume por segundo |
| `POST /v1/sessions/{id}/clips` | **cortar agora**: `{lastS}` ou `{startS,endS}`; corte manual nunca é descartado pela IA | | `POST /v1/sessions/{id}/clips` | **cortar agora**: `{lastS}` ou `{startS,endS}`; corte manual nunca é descartado pela IA |
| `GET /v1/clips?status=&session=` · `GET/PATCH /v1/clips/{id}` · `POST …/render` · `POST …/rejudge` | fila de cortes; cada corte traz `aspect` (`vertical` ou `horizontal`) = formato em que o arquivo foi renderizado | | `GET /v1/clips?status=&session=` · `GET/PATCH /v1/clips/{id}` · `POST …/render` · `POST …/rejudge` | fila de cortes; cada corte traz `aspect` (`vertical` ou `horizontal`) = formato em que o arquivo foi renderizado |
+232
View File
@@ -0,0 +1,232 @@
"""Configuração das IAs (Claude, Codex, Gemini) compartilhada com o painel — contrato em `doc/ia.md`.
O painel (Configurações → IA) escreve dois arquivos em `data/ai/`; o Clipador só LÊ:
- `settings.json` (sem segredo): quais IAs estão ligadas, modo de login (`oauth`/`apiKey`), ordem da reserva e
pausa depois de uma falha de indisponibilidade. Relido quando o `mtime` muda; ausente/inválido = padrão.
- `vault.bin`: as chaves de API, JSON cifrado com a DPAPI do Windows (usuário atual, entropia própria).
Daqui sai o ambiente (`env`) de cada chamada de CLI: no modo chave, a variável da chave só vale para a chamada;
no modo login, a variável é removida para a CLI usar a sessão já logada. O login global de cada CLI não muda.
Nos testes, a pasta e o cifrador são injetados (`AiConfig(folder, cipher=...)`); a DPAPI real só existe no Windows.
"""
from __future__ import annotations
import copy
import json
import logging
import os
import sys
import threading
from pathlib import Path
from typing import Protocol
from .config import REPO_ROOT
log = logging.getLogger("cenaforge_clipper.ai_settings")
AI_PROVIDERS = ("claude", "codex", "gemini")
# Pasta padrão dos arquivos do painel. Os testes trocam (conftest) para não ler o data/ai real.
DEFAULT_AI_DIR = REPO_ROOT / "data" / "ai"
AUTH_MODES = ("oauth", "apiKey")
DEFAULT_COOLDOWN_MIN = 15.0
DEFAULT_SETTINGS: dict = {
"version": 1,
"providers": {
"claude": {"enabled": True, "authMode": "oauth"},
"codex": {"enabled": True, "authMode": "oauth"},
"gemini": {"enabled": False, "authMode": "apiKey"},
},
"order": ["claude", "codex", "gemini"],
"fallback": {"enabled": True, "cooldownMin": DEFAULT_COOLDOWN_MIN},
}
# Variável de ambiente da chave de API de cada CLI (tabela "Ambiente de cada chamada" do doc/ia.md).
API_KEY_ENV = {"claude": "ANTHROPIC_API_KEY", "codex": "CODEX_API_KEY", "gemini": "GEMINI_API_KEY"}
GEMINI_OAUTH_ENV = "GOOGLE_GENAI_USE_GCA"
# Entropia do cofre de IA (a mesma que o painel usa ao cifrar). Não é senha: só separa este cofre dos outros.
_VAULT_ENTROPY = b"CenaForge.AI.vault.v1"
class AiVaultError(RuntimeError):
"""O cofre de IA não abriu (outro usuário/máquina, corrompido, ou DPAPI indisponível)."""
class Cipher(Protocol):
def unprotect(self, data: bytes) -> bytes: ...
class DpapiCipher:
"""DPAPI via ctypes (crypt32.dll), só a decifragem — quem cifra é o painel. Mesmo padrão de
`publisher/app/vault.py` (pacotes separados: o código é copiado, não importado)."""
CRYPTPROTECT_UI_FORBIDDEN = 0x01
def __init__(self, entropy: bytes = _VAULT_ENTROPY) -> None:
if sys.platform != "win32":
raise AiVaultError("O cofre de IA usa a DPAPI do Windows; este sistema não tem.")
import ctypes
from ctypes import wintypes
class DataBlob(ctypes.Structure):
_fields_ = [("cbData", wintypes.DWORD), ("pbData", ctypes.POINTER(ctypes.c_char))]
self._entropy = entropy
self._ctypes = ctypes
self._blob = DataBlob
self._crypt32 = ctypes.WinDLL("crypt32", use_last_error=True)
self._kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
self._kernel32.LocalFree.argtypes = [ctypes.c_void_p]
self._kernel32.LocalFree.restype = ctypes.c_void_p
fn = self._crypt32.CryptUnprotectData
fn.argtypes = [ctypes.POINTER(DataBlob), ctypes.c_void_p, ctypes.POINTER(DataBlob), ctypes.c_void_p,
ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(DataBlob)]
fn.restype = wintypes.BOOL
def _to_blob(self, data: bytes):
buffer = self._ctypes.create_string_buffer(data, len(data))
blob = self._blob(len(data), self._ctypes.cast(buffer, self._ctypes.POINTER(self._ctypes.c_char)))
return blob, buffer # o buffer precisa continuar vivo enquanto o blob for usado
def unprotect(self, data: bytes) -> bytes:
ctypes = self._ctypes
in_blob, _keep_in = self._to_blob(data)
entropy, _keep_entropy = self._to_blob(self._entropy)
out_blob = self._blob()
ok = self._crypt32.CryptUnprotectData(ctypes.byref(in_blob), None, ctypes.byref(entropy), None, None,
self.CRYPTPROTECT_UI_FORBIDDEN, ctypes.byref(out_blob))
if not ok:
raise AiVaultError(f"A DPAPI do Windows não conseguiu abrir o cofre de IA (erro {ctypes.get_last_error()}). "
"O arquivo pode ser de outro usuário ou de outro computador.")
try:
return ctypes.string_at(out_blob.pbData, out_blob.cbData)
finally:
self._kernel32.LocalFree(out_blob.pbData)
def normalize_settings(raw: object) -> dict:
"""Valida o settings.json do painel campo a campo. O que faltar ou vier errado fica no padrão do doc."""
settings = copy.deepcopy(DEFAULT_SETTINGS)
if not isinstance(raw, dict):
return settings
providers = raw.get("providers")
if isinstance(providers, dict):
for name in AI_PROVIDERS:
item = providers.get(name)
if not isinstance(item, dict):
continue
if isinstance(item.get("enabled"), bool):
settings["providers"][name]["enabled"] = item["enabled"]
if item.get("authMode") in AUTH_MODES:
settings["providers"][name]["authMode"] = item["authMode"]
order = raw.get("order")
if isinstance(order, list):
known = [p for p in dict.fromkeys(order) if p in AI_PROVIDERS]
# Quem ficou de fora da lista vai para o fim, na ordem padrão (a lista sempre tem as três).
settings["order"] = known + [p for p in AI_PROVIDERS if p not in known]
fallback = raw.get("fallback")
if isinstance(fallback, dict):
if isinstance(fallback.get("enabled"), bool):
settings["fallback"]["enabled"] = fallback["enabled"]
cooldown = fallback.get("cooldownMin")
if isinstance(cooldown, (int, float)) and not isinstance(cooldown, bool) and cooldown >= 0:
settings["fallback"]["cooldownMin"] = float(cooldown)
return settings
def _mtime(path: Path) -> int | None:
try:
return path.stat().st_mtime_ns
except OSError:
return None
class AiConfig:
"""Leitura (com cache por mtime) do settings.json e do vault.bin do painel."""
def __init__(self, folder: Path | None = None, cipher: Cipher | None = None,
environ: dict[str, str] | None = None):
self.folder = Path(folder) if folder is not None else DEFAULT_AI_DIR
self._cipher = cipher
self._environ = environ # None = os.environ do momento da chamada
self._lock = threading.RLock()
self._settings_cache: tuple[int | None, dict] | None = None
self._keys_cache: tuple[int | None, dict[str, str]] | None = None
self.vault_error: str | None = None
@property
def settings_path(self) -> Path:
return self.folder / "settings.json"
@property
def vault_path(self) -> Path:
return self.folder / "vault.bin"
def settings(self) -> dict:
"""Configuração atual (cópia). Relê o arquivo só quando o mtime muda."""
with self._lock:
stamp = _mtime(self.settings_path)
if self._settings_cache is None or self._settings_cache[0] != stamp:
raw: object = None
if stamp is not None:
try:
raw = json.loads(self.settings_path.read_text(encoding="utf-8"))
except (OSError, ValueError) as exc:
log.warning("data/ai/settings.json inválido (%s); usando o padrão", exc)
self._settings_cache = (stamp, normalize_settings(raw))
return copy.deepcopy(self._settings_cache[1])
def provider(self, name: str) -> dict:
return self.settings()["providers"].get(name, {"enabled": False, "authMode": "oauth"})
def api_keys(self) -> dict[str, str]:
"""Chaves do cofre (só as que existem). Cofre ausente = {}; cofre que não abre = {} e `vault_error`."""
with self._lock:
stamp = _mtime(self.vault_path)
if self._keys_cache is None or self._keys_cache[0] != stamp:
self._keys_cache = (stamp, self._read_vault() if stamp is not None else {})
if stamp is None:
self.vault_error = None
return dict(self._keys_cache[1])
def _read_vault(self) -> dict[str, str]:
try:
raw = self.vault_path.read_bytes()
if not raw:
self.vault_error = None
return {}
cipher = self._cipher or DpapiCipher()
data = json.loads(cipher.unprotect(raw).decode("utf-8"))
except Exception as exc: # noqa: BLE001 - cofre ilegível não derruba o juiz: segue sem chaves
self.vault_error = str(exc)[:200] or "cofre de IA ilegível"
log.warning("não abri data/ai/vault.bin: %s", self.vault_error)
return {}
self.vault_error = None
if not isinstance(data, dict):
return {}
return {k: v.strip() for k, v in data.items() if k in AI_PROVIDERS and isinstance(v, str) and v.strip()}
def has_key(self, provider: str) -> bool:
return bool(self.api_keys().get(provider))
def provider_env(self, provider: str) -> dict[str, str]:
"""Ambiente da chamada da CLI de `provider`, conforme o modo de login (tabela do doc/ia.md)."""
env = dict(os.environ if self._environ is None else self._environ)
key_var = API_KEY_ENV.get(provider)
if not key_var:
return env
mode = self.provider(provider).get("authMode", "oauth")
if mode == "apiKey":
key = self.api_keys().get(provider)
if key:
env[key_var] = key
else:
env.pop(key_var, None)
if provider == "gemini":
env.pop(GEMINI_OAUTH_ENV, None)
else:
env.pop(key_var, None)
if provider == "gemini":
env[GEMINI_OAUTH_ENV] = "true"
return env
+2 -2
View File
@@ -119,8 +119,8 @@ class Settings:
judge_model=env.get("CLIPPER_JUDGE_MODEL", ""), judge_model=env.get("CLIPPER_JUDGE_MODEL", ""),
judge_min_score=num("CLIPPER_JUDGE_MIN_SCORE", 6, 0), judge_min_score=num("CLIPPER_JUDGE_MIN_SCORE", 6, 0),
) )
if settings.judge_provider not in ("codex", "claude", "off"): if settings.judge_provider not in ("codex", "claude", "gemini", "off"):
raise ConfigError("CLIPPER_JUDGE_PROVIDER precisa ser codex, claude ou off") raise ConfigError("CLIPPER_JUDGE_PROVIDER precisa ser codex, claude, gemini ou off")
if settings.encoder not in ("auto", "libx264", "h264_nvenc"): if settings.encoder not in ("auto", "libx264", "h264_nvenc"):
raise ConfigError("CLIPPER_ENCODER precisa ser auto, libx264 ou h264_nvenc") raise ConfigError("CLIPPER_ENCODER precisa ser auto, libx264 ou h264_nvenc")
if overrides: if overrides:
+17
View File
@@ -190,6 +190,23 @@ SCHEMA = [
); );
CREATE INDEX deleted_clips_session ON deleted_clips (session_id); CREATE INDEX deleted_clips_session ON deleted_clips (session_id);
""", """,
# v11: (a) parar uma sessão à mão pausa o monitor da fonte (`monitor_paused_at` + a sessão que motivou): o monitor
# não abre sessão nova enquanto a pausa existir; religar (PATCH monitor=true, gravar pelo link ou retomar) limpa.
# (b) idioma falado na live, por fonte e por sessão ('' = CLIPPER_LANGUAGE): transcrição e textos da IA.
"""
ALTER TABLE channels ADD COLUMN monitor_paused_at TEXT;
ALTER TABLE channels ADD COLUMN monitor_paused_session INTEGER;
ALTER TABLE channels ADD COLUMN language TEXT NOT NULL DEFAULT '';
ALTER TABLE sessions ADD COLUMN language TEXT NOT NULL DEFAULT '';
""",
# v12: perfil do jogo em dois idiomas (doc/clipador/JOGOS.md). `profile_json` continua sendo o português (o que o
# painel mostra); `profile_ai_json` é o inglês, que vai nos prompts; `translated_at` = quando uma versão foi gerada
# da outra; `aliases_json` = outros nomes do jogo (categoria "Grand Theft Auto VI" e tela "GTA 6" → mesmo perfil).
"""
ALTER TABLE games ADD COLUMN profile_ai_json TEXT;
ALTER TABLE games ADD COLUMN translated_at TEXT;
ALTER TABLE games ADD COLUMN aliases_json TEXT NOT NULL DEFAULT '[]';
""",
] ]
+229 -43
View File
@@ -23,7 +23,7 @@ from .db import loads, now
from .emotes import EmoteCatalog, extract, learn_delta, message_bonus from .emotes import EmoteCatalog, extract, learn_delta, message_bonus
from .face import FaceError, FaceUnavailable from .face import FaceError, FaceUnavailable
from .hashtags import fold, to_tag from .hashtags import fold, to_tag
from .judge import JudgeError, build_scan_prompt, game_context from .judge import JudgeError, build_scan_prompt, game_context, output_language_note
from .scoring import fit_window from .scoring import fit_window
from .sources import parse_source from .sources import parse_source
@@ -52,31 +52,79 @@ def game_id(name: str) -> str:
return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido" return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:60] or "desconhecido"
PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources") PROFILE_LISTS = ("mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources", "aliases", "end_triggers")
# Teto de cada lista (o resto: 20). Missões ficam à parte (objetos, até 120).
LIST_LIMITS = {"aliases": 10, "end_triggers": 12}
MAX_MISSIONS = 120
MAX_MISSION_TRIGGERS = 8
# Sementes: perfis prontos que vêm com o repositório (ex.: GTA VI). Importados na subida só se o jogo não existe.
SEEDS_DIR = Path(__file__).resolve().parent / "seeds" / "games"
def clean_profile(raw: dict) -> dict: def _clean_text_list(values, limit: int, item_chars: int = 300) -> list[str]:
"""Normaliza um perfil de jogo (vindo da IA ou da edição à mão): textos aparados, listas sem vazios/duplicados.
Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some), comparadas sem acento/maiúscula."""
raw = raw if isinstance(raw, dict) else {}
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
for key in PROFILE_LISTS:
items, seen = [], set() items, seen = [], set()
for item in raw.get(key) or []: for item in values or []:
text = str(item or "").strip()[:300] text = str(item or "").strip()[:item_chars]
if key == "hashtags":
text = to_tag(text) or ""
if text and fold(text) not in seen:
seen.add(fold(text))
items.append(text)
continue
if text and text.lower() not in seen: if text and text.lower() not in seen:
seen.add(text.lower()) seen.add(text.lower())
items.append(text) items.append(text)
out[key] = items[:20] return items[:limit]
def clean_missions(values) -> list[dict]:
"""Missões: nome obrigatório (sem repetir), capítulo, resumo e até 8 gatilhos de fim (até 200 caracteres cada)."""
out, seen = [], set()
for raw in values or []:
if not isinstance(raw, dict):
continue
name = str(raw.get("name") or "").strip()[:160]
if not name or name.lower() in seen:
continue
seen.add(name.lower())
out.append({
"name": name,
"chapter": str(raw.get("chapter") or "").strip()[:120],
"summary": str(raw.get("summary") or "").strip()[:500],
"completion_triggers": _clean_text_list(raw.get("completion_triggers"), MAX_MISSION_TRIGGERS, 200),
})
if len(out) >= MAX_MISSIONS:
break
return out return out
def clean_profile(raw: dict) -> dict:
"""Normaliza um perfil de jogo (vindo da IA, da tradução ou da edição à mão): textos aparados, listas sem
vazios/duplicados, missões validadas. Hashtags viram tag de verdade ("rob run" → "#RobRun"; sem letra some),
comparadas sem acento/maiúscula."""
raw = raw if isinstance(raw, dict) else {}
out: dict = {k: str(raw.get(k) or "").strip()[:limit] for k, limit in (("name", 120), ("summary", 1500), ("genre", 120))}
for key in PROFILE_LISTS:
if key == "hashtags":
items, seen = [], set()
for item in raw.get(key) or []:
text = to_tag(str(item or "").strip()[:300]) or ""
if text and fold(text) not in seen:
seen.add(fold(text))
items.append(text)
out[key] = items[:20]
else:
out[key] = _clean_text_list(raw.get(key), LIST_LIMITS.get(key, 20))
out["missions"] = clean_missions(raw.get("missions"))
return out
def alias_ids(*profiles: dict | None) -> list[str]:
"""Ids normalizados dos outros nomes do jogo (das duas versões do perfil), sem repetir."""
ids: list[str] = []
for profile in profiles:
for alias in (profile or {}).get("aliases") or []:
gid = game_id(str(alias))
if gid != "desconhecido" and gid not in ids:
ids.append(gid)
return ids
class Intel: class Intel:
def __init__(self, engine: "Engine"): def __init__(self, engine: "Engine"):
self.e = engine self.e = engine
@@ -91,6 +139,37 @@ class Intel:
for key in OPTION_DEFAULTS: for key in OPTION_DEFAULTS:
if f"opt_{key}" in saved: if f"opt_{key}" in saved:
self.opts[key] = json.loads(saved[f"opt_{key}"]) self.opts[key] = json.loads(saved[f"opt_{key}"])
self.import_seeds()
# ---------------------------------------------------------------- sementes de jogos
def import_seeds(self, folder: Path | None = None) -> list[str]:
"""Importa os perfis de `seeds/games/*.json` ({name, aliases, researchedAt, sources, profileAi, profile}) que
ainda não existem no banco (por id ou alias). Nunca sobrescreve: o que você editou fica. Devolve os ids novos."""
added: list[str] = []
for path in sorted((folder or SEEDS_DIR).glob("*.json")):
try:
seed = json.loads(path.read_text(encoding="utf-8"))
name = str(seed.get("name") or "").strip()
if not name:
continue
ai = clean_profile({**(seed.get("profileAi") or {}), "name": name})
pt = clean_profile({**(seed.get("profile") or seed.get("profileAi") or {}), "name": name})
for profile in (ai, pt):
profile["aliases"] = profile["aliases"] or list(seed.get("aliases") or [])
profile["sources"] = profile["sources"] or list(seed.get("sources") or [])
gid = game_id(name)
if self.find_game(name) or any(self.find_game(a) for a in ai["aliases"]):
continue
self.e.db.run(
"INSERT INTO games (id, name, status, profile_json, profile_ai_json, aliases_json, model, researched_at,"
" translated_at) VALUES (?, ?, 'ready', ?, ?, ?, 'seed', ?, ?)",
gid, name[:120], json.dumps(pt, ensure_ascii=False), json.dumps(ai, ensure_ascii=False),
json.dumps(alias_ids(ai, pt)), seed.get("researchedAt") or now(), seed.get("researchedAt") or now())
added.append(gid)
log.info("jogo importado da semente %s: %s", path.name, name)
except (OSError, ValueError) as exc:
log.warning("semente de jogo %s inválida: %s", path.name, exc)
return added
# ---------------------------------------------------------------- opções (painel) # ---------------------------------------------------------------- opções (painel)
def set_options(self, values: dict) -> dict: def set_options(self, values: dict) -> dict:
@@ -202,7 +281,7 @@ class Intel:
self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?", self.e.db.run("UPDATE sessions SET game = ?, game_source = ?, games_json = ? WHERE id = ?",
name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id) name[:120], source, json.dumps(history[-20:], ensure_ascii=False), session_id)
gid = game_id(name) gid = game_id(name)
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid): if not self.find_game(name):
self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120]) self.e.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')", gid, name[:120])
def research_pending(self) -> None: def research_pending(self) -> None:
@@ -212,53 +291,142 @@ class Intel:
self.research(game["id"]) self.research(game["id"])
def research(self, gid: str) -> dict: def research(self, gid: str) -> dict:
"""Pesquisa na web EM INGLÊS (missões e gatilhos inclusos) → versão da IA; depois traduz para português (a que
o painel mostra). Tradução falhou: as duas ficam em inglês e `error` explica (o jogo continua utilizável)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid) game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game: if not game:
raise JudgeError("jogo não encontrado") raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled: if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para pesquisar o jogo") raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para pesquisar o jogo")
title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "") title = (self.e.db.get("SELECT title FROM sessions WHERE game = ? ORDER BY id DESC LIMIT 1", game["name"]) or {}).get("title", "")
notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")] notes = [n.get("text", "") for n in loads(game.get("notes_json"), []) if n.get("text")]
try: try:
profile = self.e.judge.research_game(game["name"], title, notes) ai = clean_profile(self.e.judge.research_game(game["name"], title, notes))
model = self.e.judge.responder() # quem DE FATO respondeu (pode ter sido a IA reserva)
except (JudgeError, json.JSONDecodeError) as exc: except (JudgeError, json.JSONDecodeError) as exc:
self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid) self.e.db.run("UPDATE games SET status = 'error', error = ? WHERE id = ?", str(exc)[:300], gid)
raise JudgeError(str(exc)) from exc raise JudgeError(str(exc)) from exc
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, model = ?, researched_at = ? WHERE id = ?", self.e.db.run("UPDATE games SET profile_ai_json = ?, model = ?, researched_at = ? WHERE id = ?",
json.dumps(profile, ensure_ascii=False), f"{self.e.judge.provider}:{self.e.judge.model}", now(), gid) json.dumps(ai, ensure_ascii=False), model, now(), gid)
return profile pt, error = self._translated(ai, "pt-BR")
self._store(gid, pt=pt, ai=ai, translated=error is None, error=error)
return ai
def save_profile(self, gid: str, profile: dict) -> dict: def _translated(self, profile: dict, target: str) -> tuple[dict, str | None]:
"""Grava o perfil editado à mão no painel. Vale na hora para a IA (status 'ready').""" """(perfil traduzido, None) ou (o próprio perfil, motivo) se a IA está desligada ou a tradução falhou."""
if not self.e.judge.enabled:
return profile, "IA desligada: a outra versão do perfil não foi atualizada"
try:
out = clean_profile(self.e.judge.translate_game(profile, target))
except (JudgeError, json.JSONDecodeError) as exc:
return profile, f"tradução falhou: {exc}"[:300]
# A tradução nunca mexe em nome, hashtags, fontes e outros nomes (a IA às vezes "traduz" o que não devia).
for key in ("name", "hashtags", "sources", "aliases"):
out[key] = profile.get(key) or out.get(key)
if len(out.get("missions") or []) != len(profile.get("missions") or []):
return profile, "tradução perdeu missões: a outra versão ficou igual à original"
return out, None
def _store(self, gid: str, *, pt: dict | None = None, ai: dict | None = None, translated: bool = False,
error: str | None = None, edited: bool = False, extra_sql: str = "", extra: tuple = ()) -> None:
"""Grava as versões que vieram (None = não mexe), os outros nomes (união das duas) e o estado."""
game = self.e.db.get("SELECT profile_json, profile_ai_json FROM games WHERE id = ?", gid) or {}
pt_now = pt if pt is not None else loads(game.get("profile_json"), None)
ai_now = ai if ai is not None else loads(game.get("profile_ai_json"), None)
self.e.db.run(
"UPDATE games SET status = 'ready', profile_json = ?, profile_ai_json = ?, aliases_json = ?, error = ?,"
" translated_at = CASE WHEN ? THEN ? ELSE translated_at END,"
" edited_at = CASE WHEN ? THEN ? ELSE edited_at END" + extra_sql + " WHERE id = ?",
json.dumps(pt_now, ensure_ascii=False) if pt_now is not None else None,
json.dumps(ai_now, ensure_ascii=False) if ai_now is not None else None,
json.dumps(alias_ids(ai_now, pt_now)), error, int(translated), now(), int(edited), now(), *extra, gid)
def save_profile(self, gid: str, profile: dict, lang: str = "pt") -> dict:
"""Grava a edição à mão na versão `lang` ("pt" = a que você lê; "en" = a da IA) e traduz para a outra. Com a IA
desligada, grava só essa e a outra fica como estava (`translatedAt` não muda: o painel avisa que está velha)."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid): if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado") raise JudgeError("jogo não encontrado")
clean = clean_profile(profile) clean = clean_profile(profile)
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, edited_at = ? WHERE id = ?", target = "en-US" if lang == "pt" else "pt-BR"
json.dumps(clean, ensure_ascii=False), now(), gid) other, error = self._translated(clean, target)
translated = error is None
if lang == "pt":
self._store(gid, pt=clean, ai=other if translated else None, translated=translated, error=error, edited=True)
else:
self._store(gid, ai=clean, pt=other if translated else None, translated=translated, error=error, edited=True)
return clean return clean
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "", def translate(self, gid: str) -> dict:
history: list[dict] | None = None) -> tuple[dict, str]: """Gera a versão da IA (inglês) a partir da portuguesa — para jogos de antes da v12."""
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). O pedido fica guardado e
volta em toda pesquisa. Devolve (perfil, resposta curta da IA)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid) game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game: if not game:
raise JudgeError("jogo não encontrado") raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled: if not self.e.judge.enabled:
raise JudgeError("IA desligada: ligue o Codex ou o Claude para editar o perfil pela IA") raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para traduzir o perfil")
current = loads(game["profile_json"], None) or clean_profile({"name": game["name"]}) pt = loads(game["profile_json"], None)
if not pt:
raise JudgeError("o jogo ainda não tem perfil para traduzir")
ai, error = self._translated(clean_profile(pt), "en-US")
if error:
raise JudgeError(error)
self._store(gid, ai=ai, translated=True)
return ai
def refine(self, gid: str, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> tuple[dict, str]:
"""Pede à IA para acrescentar/corrigir algo no perfil (opcionalmente numa seção). Aplica na versão em inglês
(a da IA; jogo antigo sem ela: na portuguesa) e traduz para português. O pedido fica guardado e volta em toda
pesquisa. Devolve (perfil em português, resposta curta da IA em português)."""
game = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
if not game:
raise JudgeError("jogo não encontrado")
if not self.e.judge.enabled:
raise JudgeError("IA desligada: escolha uma IA (Codex, Claude ou Gemini) para editar o perfil pela IA")
current = (loads(game.get("profile_ai_json"), None) or loads(game["profile_json"], None)
or clean_profile({"name": game["name"]}))
try: try:
data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history) data = self.e.judge.refine_game(game["name"], current, instruction, search, section, history)
model = self.e.judge.responder() # antes da tradução, que também passa pelo juiz
except json.JSONDecodeError as exc: except json.JSONDecodeError as exc:
raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc raise JudgeError(f"a IA devolveu um perfil inválido: {exc}") from exc
reply = str(data.get("reply") or "").strip()[:600] reply = str(data.get("reply") or "").strip()[:600]
profile = clean_profile(data) ai = clean_profile(data)
pt, error = self._translated(ai, "pt-BR")
notes = loads(game.get("notes_json"), []) notes = loads(game.get("notes_json"), [])
notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})}) notes.append({"text": instruction, "at": now(), **({"section": section} if section else {})})
self.e.db.run("UPDATE games SET status = 'ready', profile_json = ?, error = NULL, notes_json = ?, edited_at = ?," self._store(gid, ai=ai, pt=pt, translated=error is None, error=error, edited=True,
" model = ? WHERE id = ?", json.dumps(profile, ensure_ascii=False), extra_sql=", notes_json = ?, model = ?",
json.dumps(notes[-30:], ensure_ascii=False), now(), f"{self.e.judge.provider}:{self.e.judge.model}", gid) extra=(json.dumps(notes[-30:], ensure_ascii=False), model))
return profile, reply return pt, reply
def add_game(self, name: str, notes: str = "") -> str:
"""Cadastra um jogo pelo painel (antes só nascia da categoria da live) e pesquisa em segundo plano.
Já existe (pelo id ou por outro nome dele) → UserError 409."""
name = name.strip()[:120]
if not name:
raise ValueError("Diga o nome do jogo.")
existing = self.find_game(name)
if existing:
raise LookupError(f"“{existing['name']}” já está na lista.")
gid = game_id(name)
note_list = [{"text": notes.strip()[:1500], "at": now()}] if notes.strip() else []
self.e.db.run("INSERT INTO games (id, name, status, notes_json) VALUES (?, ?, 'pending', ?)",
gid, name, json.dumps(note_list, ensure_ascii=False))
if self.e.judge.enabled:
threading.Thread(target=self._research_quietly, args=(gid,), name=f"game-{gid}", daemon=True).start()
return gid
def _research_quietly(self, gid: str) -> None:
try:
self.research(gid)
except JudgeError as exc:
log.warning("pesquisa do jogo %s falhou: %s", gid, exc)
def delete_game(self, gid: str) -> None:
"""Apaga o jogo. Sessões não mudam; se o jogo voltar numa live, nasce de novo e é pesquisado."""
if not self.e.db.get("SELECT 1 FROM games WHERE id = ?", gid):
raise JudgeError("jogo não encontrado")
self.e.db.run("DELETE FROM games WHERE id = ?", gid)
def delete_note(self, gid: str, index: int) -> None: def delete_note(self, gid: str, index: int) -> None:
"""Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda).""" """Esquece um pedido (ele deixa de voltar nas próximas pesquisas; o perfil atual não muda)."""
@@ -270,11 +438,26 @@ class Intel:
notes.pop(index) notes.pop(index)
self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid) self.e.db.run("UPDATE games SET notes_json = ? WHERE id = ?", json.dumps(notes, ensure_ascii=False), gid)
def profile(self, name: str) -> dict | None: def find_game(self, name: str) -> dict | None:
if not name: """Linha do jogo pelo nome: id normalizado ou, se não achar, um jogo que tem esse nome entre os outros nomes."""
gid = game_id(name or "")
if not name or gid == "desconhecido":
return None return None
row = self.e.db.get("SELECT profile_json FROM games WHERE id = ? AND status = 'ready'", game_id(name)) row = self.e.db.get("SELECT * FROM games WHERE id = ?", gid)
return loads(row["profile_json"], None) if row else None if row:
return row
# aliases_json é uma lista JSON de ids: procura o id entre aspas (LIKE barato, confere no Python).
for row in self.e.db.all("SELECT * FROM games WHERE aliases_json LIKE ?", f'%"{gid}"%'):
if gid in loads(row.get("aliases_json"), []):
return row
return None
def profile(self, name: str) -> dict | None:
"""Perfil que vai para a IA: a versão em inglês; jogo antigo, sem ela, usa a portuguesa."""
row = self.find_game(name)
if not row or row["status"] != "ready":
return None
return loads(row.get("profile_ai_json"), None) or loads(row["profile_json"], None)
def session_game(self, session: dict) -> tuple[str, dict | None]: def session_game(self, session: dict) -> tuple[str, dict | None]:
"""(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho; """(nome do jogo, perfil) da sessão — o mesmo critério do contexto: jogo confirmado por você vale sozinho;
@@ -291,8 +474,11 @@ class Intel:
memory = loads(session.get("memory_json"), []) memory = loads(session.get("memory_json"), [])
confirmed = session.get("game_source") == "user" and bool(session.get("game")) confirmed = session.get("game_source") == "user" and bool(session.get("game"))
profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", ""))) profile = self.profile(session.get("game", "")) or (None if confirmed else self.profile(session.get("screen_game", "")))
return game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""), text = game_context(session.get("game", ""), session.get("screen_game", ""), profile, session.get("title", ""),
" | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed) " | ".join(m["summary"] for m in memory[-3:] if m.get("summary")), confirmed=confirmed)
# Sessão em outro idioma (fonte gringa): o editor e a varredura escrevem título/legenda nesse idioma.
note = output_language_note(session.get("language") or self.e.settings.language)
return f"{text}\n{note}" if note else text
# ---------------------------------------------------------------- frames # ---------------------------------------------------------------- frames
def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]: def frames(self, session: dict, times: list[float], tag: str) -> list[tuple[float, Path]]:
+410 -71
View File
@@ -9,8 +9,13 @@ Quatro usos, todos com saída JSON validada por schema:
3. **pesquisa do jogo** (com busca na web): o que é o jogo, o que rende corte nele, gírias, novidades. 3. **pesquisa do jogo** (com busca na web): o que é o jogo, o que rende corte nele, gírias, novidades.
4. **webcam**: onde está a câmera do streamer no quadro (retângulo normalizado), para o layout câmera-em-cima. 4. **webcam**: onde está a câmera do streamer no quadro (retângulo normalizado), para o layout câmera-em-cima.
Provedores: `codex` (`codex exec`, imagens com `-i`, web com `--search`, `--output-schema`) ou `claude` Provedores: `codex` (`codex exec`, imagens com `-i`, web com `--search`, `--output-schema`), `claude`
(`claude -p --json-schema`; imagens pela ferramenta Read, web por WebSearch/WebFetch). (`claude -p --json-schema`; imagens pela ferramenta Read, web por WebSearch/WebFetch) ou `gemini`
(`gemini -p -o json --approval-mode plan`; schema no prompt, imagens por `@arquivo`, web por google_web_search).
Login, chave de API e IA reserva vêm de Configurações → IA no painel (`data/ai/`, contrato em `doc/ia.md`): se a
IA escolhida falhar por indisponibilidade (cota, sobrecarga, login, rede, CLI ausente, tempo esgotado), a próxima
da ordem tenta com o modelo padrão dela, e a que falhou fica em pausa por `cooldownMin`.
""" """
from __future__ import annotations from __future__ import annotations
@@ -23,21 +28,32 @@ import shutil
import subprocess import subprocess
import sys import sys
import tempfile import tempfile
import threading
import time
from dataclasses import dataclass from dataclasses import dataclass
from datetime import datetime, timezone
from pathlib import Path from pathlib import Path
from . import layout from . import layout
from .ai_settings import AiConfig
from .scoring import ChatMessage, Word, fit_window from .scoring import ChatMessage, Word, fit_window
log = logging.getLogger("cenaforge_clipper.judge") log = logging.getLogger("cenaforge_clipper.judge")
PROVIDERS = ("codex", "claude", "off") PROVIDERS = ("codex", "claude", "gemini", "off")
DEFAULT_MODELS = {"codex": "gpt-6-luna", "claude": "haiku"} AI_ENABLED = ("codex", "claude", "gemini")
DEFAULT_MODELS = {"codex": "gpt-6-luna", "claude": "haiku", "gemini": "gemini-3.5-flash"}
CLAUDE_MODELS = [ CLAUDE_MODELS = [
{"id": "haiku", "label": "Haiku (mais barato)"}, {"id": "haiku", "label": "Haiku (mais barato)"},
{"id": "sonnet", "label": "Sonnet (equilíbrio)"}, {"id": "sonnet", "label": "Sonnet (equilíbrio)"},
{"id": "opus", "label": "Opus (mais capaz, mais caro)"}, {"id": "opus", "label": "Opus (mais capaz, mais caro)"},
] ]
# Lista estática (`gemini models -o json` existe, mas custa um processo Node a cada abertura do painel).
GEMINI_MODELS = [
{"id": "gemini-3.5-flash", "label": "3.5 Flash (rápido e barato)"},
{"id": "gemini-3.1-flash-lite", "label": "3.1 Flash-Lite (mais barato)"},
{"id": "gemini-2.5-pro", "label": "2.5 Pro (mais capaz, mais caro)"},
]
CONTEXT_AFTER_S = 15.0 CONTEXT_AFTER_S = 15.0
# Padrões de duração = os da configuração do corte (layout.DEFAULTS): mínimo 60 s, máximo 90 s, volta até 2 min. # Padrões de duração = os da configuração do corte (layout.DEFAULTS): mínimo 60 s, máximo 90 s, volta até 2 min.
DEFAULT_MIN_S = float(layout.DEFAULTS["duration"]["minS"]) DEFAULT_MIN_S = float(layout.DEFAULTS["duration"]["minS"])
@@ -172,10 +188,22 @@ SCAN_SCHEMA = {
"required": ["screen_game", "has_webcam", "summary", "moments"], "required": ["screen_game", "has_webcam", "summary", "moments"],
"additionalProperties": False, "additionalProperties": False,
} }
_MISSION = {
"type": "object",
"properties": {
"name": {"type": "string"},
"chapter": {"type": "string"},
"summary": {"type": "string"},
"completion_triggers": {"type": "array", "items": {"type": "string"}},
},
"required": ["name", "chapter", "summary", "completion_triggers"],
"additionalProperties": False,
}
PROFILE_SCHEMA = { PROFILE_SCHEMA = {
"type": "object", "type": "object",
"properties": { "properties": {
"name": {"type": "string"}, "name": {"type": "string"},
"aliases": {"type": "array", "items": {"type": "string"}},
"summary": {"type": "string"}, "summary": {"type": "string"},
"genre": {"type": "string"}, "genre": {"type": "string"},
"mechanics": {"type": "array", "items": {"type": "string"}}, "mechanics": {"type": "array", "items": {"type": "string"}},
@@ -185,8 +213,11 @@ PROFILE_SCHEMA = {
"news": {"type": "array", "items": {"type": "string"}}, "news": {"type": "array", "items": {"type": "string"}},
"hashtags": {"type": "array", "items": {"type": "string"}}, "hashtags": {"type": "array", "items": {"type": "string"}},
"sources": {"type": "array", "items": {"type": "string"}}, "sources": {"type": "array", "items": {"type": "string"}},
"missions": {"type": "array", "items": _MISSION},
"end_triggers": {"type": "array", "items": {"type": "string"}},
}, },
"required": ["name", "summary", "genre", "mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags", "sources"], "required": ["name", "aliases", "summary", "genre", "mechanics", "clip_worthy", "avoid", "jargon", "news", "hashtags",
"sources", "missions", "end_triggers"],
"additionalProperties": False, "additionalProperties": False,
} }
CAM_SCHEMA = { CAM_SCHEMA = {
@@ -242,37 +273,57 @@ moments=[] (é o normal na maior parte do tempo — não force). Não repita um
- title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui). - title/caption/reason como um editor faria (título ≤ 70 caracteres, verdadeiro; hashtags só do que há aqui).
Não use ferramentas além do que foi entregue. Responda só com o JSON pedido.""" Não use ferramentas além do que foi entregue. Responda só com o JSON pedido."""
PROFILE_SYSTEM = """Você pesquisa jogos para um editor de cortes de live em português do Brasil. Use a busca na # Perfil do jogo em INGLÊS (doc/clipador/JOGOS.md): é o que vai nos prompts; a tradução para português é só para o
web para confirmar o que é o jogo (nome da categoria da Twitch pode ser abreviado ou ambíguo). Seja factual e # dono ler no painel. Pesquisar em inglês também acha mais fonte (wikis, guias) — sobretudo lista de missões.
cite as fontes (URLs). Responda só com o JSON pedido, textos em português do Brasil. PROFILE_SYSTEM = """You research video games for a live-stream clip editor. Use web search to confirm what the game
- summary: 2–3 frases do que é o jogo e como se joga. is (a Twitch category name can be abbreviated or ambiguous). Be factual and cite sources (URLs). Answer only with the
- mechanics: até 8 mecânicas/sistemas que aparecem em gameplay. requested JSON, all text in ENGLISH.
- clip_worthy: até 10 situações que rendem corte NESTE jogo (específicas, não genéricas). - aliases: up to 10 other names streamers, chat and stream categories use (abbreviations, numbers, local titles).
- avoid: até 6 situações que parecem momento mas não rendem (menus, farm, fila...). - summary: 2-3 sentences on what the game is and how it plays.
- jargon: até 12 termos/gírias que streamer e chat usam (para entender a transcrição). - mechanics: up to 8 systems/activities that show up in gameplay.
- news: até 6 novidades recentes com mês/ano (lançamento, atualização, polêmica) que tornam informação valiosa. - clip_worthy: up to 10 situations that make a good clip IN THIS GAME (specific, not generic).
- hashtags: 3 a 6 hashtags que o público usa para ESTE jogo no TikTok, Shorts e Reels (Brasil): o nome do jogo sem - avoid: up to 6 situations that look like a moment but are not (menus, grinding, queues...).
espaço, abreviação conhecida, o modo/gênero quando for buscado (ex.: GTARP). A primeira é a principal do jogo. - jargon: up to 12 terms/slang streamers and chat use (to understand the transcript), including Brazilian
Escreva com "#", sem inventar tag que ninguém usa. Portuguese slang when the game is popular in Brazil.
- sources: até 5 URLs usadas. - news: up to 6 recent news items with month/year (release, update, controversy) that make information valuable.
Se vierem "pedidos do usuário", eles valem mais que a pesquisa: inclua o que ele pediu para acrescentar e respeite - hashtags: 3 to 6 hashtags the audience uses for THIS game on TikTok, Shorts and Reels (international and Brazil):
o que ele mandou tirar ou corrigir (ele conhece o canal e o jogo).""" the game name without spaces, the known abbreviation, the mode/genre when people search it (e.g. GTARP). The
first one is the main tag. Write them with "#" and never invent a tag nobody uses.
- missions: the game's STORY missions exactly as reliable sources list them (official wiki, major guides), ONLY if
that list is public; official mission names, in story order; up to 120. For each: name; chapter (act/chapter or
""); summary (one sentence); completion_triggers (up to 4): what visibly or audibly marks the end of THAT mission
(e.g. "MISSION PASSED" banner, result/score screen, final cutscene, a specific objective text or line). If the
game is not released yet or the list is not public, return missions=[] - NEVER invent missions.
- end_triggers: up to 10 general signs that a mission/objective just ended in this game (banner text, sound,
result screen, money/reward popup, cutscene, failure screen like "MISSION FAILED"/"WASTED").
- sources: up to 8 URLs you used.
If "user requests" come along, they outweigh the research: add what the user asked to add and respect what they
asked to remove or fix (they know the channel and the game). The requests may be written in Portuguese."""
REFINE_SYSTEM = """Você mantém o perfil de um jogo usado por um editor de cortes de live em português do Brasil. REFINE_SYSTEM = """You maintain the profile of a game used by a live-stream clip editor. The profile is in ENGLISH.
Recebe o perfil ATUAL (JSON) e um PEDIDO do usuário (acrescentar, corrigir, tirar ou detalhar algo). Devolva o You receive the CURRENT profile (JSON) and a REQUEST from the user, usually written in Brazilian Portuguese (add,
perfil COMPLETO atualizado, no mesmo formato: fix, remove or detail something). Return the COMPLETE updated profile, same format, all profile text in ENGLISH:
- mantenha tudo o que o pedido não mexe, com o mesmo texto; - keep everything the request does not touch, with the same text;
- aplique o pedido no campo certo (situação que rende corte → clip_worthy; o que não rende → avoid; gíria → jargon; - apply the request to the right field (clip-worthy situation -> clip_worthy; what is not -> avoid; slang -> jargon;
mecânica → mechanics; novidade → news com mês/ano; hashtag do jogo → hashtags, com "#", a principal primeiro), mechanic -> mechanics; news -> news with month/year; game hashtag -> hashtags with "#", main one first; story
escrito no estilo dos itens que já estão lá; mission -> missions; general "mission is over" sign -> end_triggers; other name -> aliases), in the style of the
- os limites de tamanho das listas podem crescer até 15 itens quando o usuário pedir para acrescentar; existing items;
- se precisar confirmar um fato, pode usar a busca na web e acrescentar a URL em sources; - lists may grow up to 15 items when the user asks to add (missions up to 120);
- o usuário conhece o canal e o jogo: o que ele afirma vale, mesmo que você não ache na web; - to confirm a fact you may use web search and add the URL to sources; never invent missions;
- se vier uma SEÇÃO em foco, o pedido é sobre ela: mexa nela (outras só se o pedido disser); - the user knows the channel and the game: what they state is right, even if you cannot find it online;
- pode transformar um pedido genérico em itens concretos e úteis para o editor (ex.: "reação do streamer conta" - if a SECTION in focus comes along, the request is about it (touch other sections only if the request says so);
vira "Streamer grita, xinga ou ri alto logo depois de uma morte ou fuga"); - you may turn a vague request into concrete, useful items for the editor;
- reply: 1–2 frases para o usuário dizendo o que você mudou (ou, se o pedido for uma pergunta, a resposta). - reply: 1-2 sentences IN BRAZILIAN PORTUGUESE telling the user what you changed (or, if the request is a
Textos em português do Brasil. Responda só com o JSON pedido.""" question, the answer, also in Portuguese).
Answer only with the requested JSON."""
TRANSLATE_SYSTEM = """You translate the profile of a video game (JSON) between English and Brazilian Portuguese for a
live-stream clip editor. Return the same JSON structure with the same number of items in every list and in the same
order. Translate summaries and descriptions naturally. Keep AS IS: the game name, proper names (characters, places,
gangs, vehicles), OFFICIAL mission names, on-screen texts quoted in triggers (e.g. "MISSION PASSED"), hashtags,
aliases and URLs. Slang in jargon stays as players say it (you may add a short meaning). Answer only with the JSON."""
TRANSLATE_TARGETS = {"pt-BR": "Brazilian Portuguese (pt-BR)", "en-US": "English (en-US)"}
REFINE_SCHEMA = { REFINE_SCHEMA = {
"type": "object", "type": "object",
@@ -281,8 +332,8 @@ REFINE_SCHEMA = {
"additionalProperties": False, "additionalProperties": False,
} }
PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "avoid": "Evitar", "mechanics": "Mecânicas", PROFILE_SECTIONS = {"summary": "Resumo", "clip_worthy": "O que rende corte", "avoid": "Evitar", "mechanics": "Mecânicas",
"hashtags": "Hashtags", "hashtags": "Hashtags", "news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes",
"news": "Novidades", "jargon": "Gírias e termos", "sources": "Fontes"} "missions": "Missões", "end_triggers": "Gatilhos de fim de missão", "aliases": "Outros nomes"}
CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e, CAM_SYSTEM = """Você analisa frames de uma live. Diga se há uma webcam/câmera do streamer sobreposta ao jogo e,
se houver, o retângulo DELA (só a câmera, sem bordas do overlay) em coordenadas normalizadas 0–1 do quadro: se houver, o retângulo DELA (só a câmera, sem bordas do overlay) em coordenadas normalizadas 0–1 do quadro:
@@ -305,10 +356,98 @@ class Verdict:
class JudgeError(RuntimeError): class JudgeError(RuntimeError):
pass """Falha da IA. `unavailable`: True = indisponibilidade (dispara a reserva), False = erro de conteúdo (não
troca de IA), None = decidir pelo texto (`is_availability_error`)."""
def __init__(self, message: str, unavailable: bool | None = None):
super().__init__(message)
self.unavailable = unavailable
# ---------------------------------------------------------------- reserva: o que é "indisponível" (doc/ia.md)
# Falha que não é culpa do pedido: cota/limite, sobrecarga, login/chave, rede, CLI ausente e tempo esgotado.
_AVAILABILITY_PATTERNS = re.compile(
r"rate[\s_-]?limit|too many requests|\b429\b|quota|resource[\s_]exhausted|usage limit|credit balance"
r"|overloaded|\b529\b|\b503\b|unavailable"
r"|\b401\b|\b403\b|unauthori[sz]ed|not logged in|invalid[\s_-]?api[\s_-]?key|api key not valid|IneligibleTier"
r"|\bECONN\w*|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|network"
r"|timed? ?out|tempo esgotado|passou de \d+ s"
r"|n[ãa]o encontrad[oa]|not found in path|n[ãa]o consegui rodar|command not found|is not recognized",
re.IGNORECASE,
)
def is_availability_error(text: str) -> bool:
"""True quando a mensagem de erro indica que a IA está indisponível (e vale tentar a reserva)."""
return bool(text) and bool(_AVAILABILITY_PATTERNS.search(text))
def extract_json_object(text: str, fences: bool = True) -> dict | None:
"""Primeiro objeto JSON do texto (tolera cercas ```json e texto em volta). None se não houver.
`fences=False` ignora cercas (para o envelope da CLI, cujo texto escapado pode conter uma)."""
if not text:
return None
body = text.strip()
fence = re.search(r"```(?:json)?\s*(.*?)```", body, re.S | re.I) if fences else None
candidates = ([fence.group(1).strip()] if fence else []) + [body]
decoder = json.JSONDecoder()
for candidate in candidates:
for match in re.finditer(r"\{", candidate):
try:
value, _end = decoder.raw_decode(candidate, match.start())
except json.JSONDecodeError:
continue
if isinstance(value, dict):
return value
return None
# ---------------------------------------------------------------- prompts # ---------------------------------------------------------------- prompts
# Idiomas que o serviço conhece (fonte/sessão `language`; o painel oferece os mesmos). Nome legível para o prompt.
LANGUAGE_NAMES = {"pt-BR": "português do Brasil", "en-US": "English (US)", "es-419": "Español (Latinoamérica)"}
DEFAULT_LANGUAGE = "pt-BR"
def output_language_note(language: str | None) -> str:
"""Linha que vai no contexto do EDITOR e da VARREDURA quando a saída não é em português: título, legenda e
hashtags no idioma do público. Vazia para pt-BR (os prompts já são em português)."""
code = (language or "").strip() or DEFAULT_LANGUAGE
if code == DEFAULT_LANGUAGE:
return ""
name = LANGUAGE_NAMES.get(code, code)
return (f"Idioma de saída: {name}. Título, legenda e hashtags em {name}, naturais para o público desse idioma "
f"(a transcrição e o chat podem estar em outro idioma; não traduza literalmente, escreva como um editor nativo).")
MISSIONS_IN_PROMPT = 25
MISSIONS_PROMPT_CHARS = 1500
def mission_lines(profile: dict) -> list[str]:
"""Gatilhos de fim de missão e as missões (nome + gatilhos) para o prompt, com teto de tamanho: o perfil do GTA
pode ter 100+ missões, e o contexto vai em todo julgamento."""
lines: list[str] = []
triggers = [str(t) for t in (profile.get("end_triggers") or [])[:10] if t]
if triggers:
lines.append("Sinais de fim de missão/objetivo neste jogo: " + "; ".join(triggers))
missions = [m for m in (profile.get("missions") or []) if isinstance(m, dict) and m.get("name")]
if missions:
parts, used = [], 0
for m in missions[:MISSIONS_IN_PROMPT]:
ends = " / ".join(str(t) for t in (m.get("completion_triggers") or [])[:2] if t)
item = f"{m['name']}" + (f" (fim: {ends})" if ends else "")
if used + len(item) > MISSIONS_PROMPT_CHARS:
break
parts.append(item)
used += len(item) + 2
extra = len(missions) - len(parts)
lines.append("Missões da história: " + "; ".join(parts) + (f"; …e mais {extra}" if extra > 0 else ""))
if triggers or missions:
lines.append("Se o trecho é o fim de uma missão, termine o corte logo depois do gatilho de fim "
"(o momento de vitória/falha é o clímax).")
return lines
def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "", def game_context(game: str, screen_game: str, profile: dict | None, live_title: str, history: str = "",
confirmed: bool = False) -> str: confirmed: bool = False) -> str:
lines = [f"Título da live: {live_title or '(desconhecido)'}"] lines = [f"Título da live: {live_title or '(desconhecido)'}"]
@@ -327,6 +466,7 @@ def game_context(game: str, screen_game: str, profile: dict | None, live_title:
("jargon", "Gírias/termos"), ("news", "Novidades")): ("jargon", "Gírias/termos"), ("news", "Novidades")):
if profile.get(key): if profile.get(key):
lines.append(f"{label}: " + "; ".join(profile[key][:10])) lines.append(f"{label}: " + "; ".join(profile[key][:10]))
lines.extend(mission_lines(profile))
if history: if history:
lines.append(f"O que aconteceu antes na live: {history}") lines.append(f"O que aconteceu antes na live: {history}")
return "\n".join(lines) return "\n".join(lines)
@@ -453,6 +593,34 @@ def find_claude() -> list[str] | None:
return [exe] if exe else None return [exe] if exe else None
def find_gemini() -> list[str] | None:
"""Comando do Gemini CLI. No Windows o npm instala `gemini.cmd` (mesmo problema do `codex.cmd`): rodamos o
`bundle/gemini.js` do pacote direto pelo Node. `GEMINI_BIN` força um caminho (.js roda pelo Node)."""
env = os.environ.get("GEMINI_BIN")
if env:
return [shutil.which("node") or "node", env] if env.endswith(".js") else [env]
if sys.platform != "win32":
exe = shutil.which("gemini")
return [exe] if exe else None
cmd = shutil.which("gemini.cmd") or shutil.which("gemini")
node = shutil.which("node")
if cmd and node:
js = Path(cmd).parent / "node_modules" / "@google" / "gemini-cli" / "bundle" / "gemini.js"
if js.is_file():
return [node, str(js)]
exe = shutil.which("gemini.exe")
return [exe] if exe else None
def find_cli(provider: str) -> list[str] | None:
"""Comando da CLI do provedor (None = não instalada). Resolve na hora (os testes trocam as funções)."""
finder = {"codex": find_codex, "claude": find_claude, "gemini": find_gemini}.get(provider)
return finder() if finder else None
PROVIDER_NAMES = {"codex": "Codex", "claude": "Claude", "gemini": "Gemini"}
def codex_models(cache: Path | None = None) -> list[dict]: def codex_models(cache: Path | None = None) -> list[dict]:
"""Modelos que o Codex lista para esta conta (cache que a própria CLI mantém).""" """Modelos que o Codex lista para esta conta (cache que a própria CLI mantém)."""
cache = cache or Path.home() / ".codex" / "models_cache.json" cache = cache or Path.home() / ".codex" / "models_cache.json"
@@ -469,12 +637,21 @@ def codex_models(cache: Path | None = None) -> list[dict]:
# ---------------------------------------------------------------- IA # ---------------------------------------------------------------- IA
class Judge: class Judge:
def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = ""): def __init__(self, provider: str, model: str, workdir: Path, analyst_model: str = "",
ai: AiConfig | None = None, clock=time.time):
self.provider = provider if provider in PROVIDERS else "codex" self.provider = provider if provider in PROVIDERS else "codex"
self.model = model or DEFAULT_MODELS.get(self.provider, "") self.model = model or DEFAULT_MODELS.get(self.provider, "")
# Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor. # Modelo do ANALISTA (1º juiz, vê os frames). Vazio = o mesmo do editor.
self.analyst_model = analyst_model self.analyst_model = analyst_model
self.workdir = workdir self.workdir = workdir
# Configurações → IA do painel (data/ai): login/chave por provedor e ordem da reserva.
self.ai = ai or AiConfig()
self._clock = clock
# Pausas da reserva, em memória (cada processo tem as suas): provedor → (até, motivo).
self._pauses: dict[str, tuple[float, str]] = {}
self._pause_lock = threading.Lock()
# Quem respondeu a última chamada DESTA thread ("provedor:modelo"): o juiz roda em várias threads.
self._local = threading.local()
def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None: def configure(self, provider: str, model: str, analyst_model: str | None = None) -> None:
if provider not in PROVIDERS: if provider not in PROVIDERS:
@@ -486,19 +663,75 @@ class Judge:
@property @property
def enabled(self) -> bool: def enabled(self) -> bool:
return self.provider in ("codex", "claude") return self.provider in AI_ENABLED
def command(self) -> list[str] | None: def command(self) -> list[str] | None:
return find_codex() if self.provider == "codex" else find_claude() if self.provider == "claude" else None return find_cli(self.provider) if self.enabled else None
def responder(self) -> str:
""""provedor:modelo" de quem respondeu a última chamada desta thread (a reserva pode ter respondido)."""
return getattr(self._local, "responder", None) or f"{self.provider}:{self.model}"
# ---------- reserva
def pauses(self) -> dict[str, tuple[float, str]]:
"""Pausas ainda valendo (as vencidas saem)."""
now = self._clock()
with self._pause_lock:
self._pauses = {p: v for p, v in self._pauses.items() if v[0] > now}
return dict(self._pauses)
def pause(self, provider: str, reason: str, minutes: float | None = None) -> None:
if minutes is None:
minutes = float(self.ai.settings()["fallback"]["cooldownMin"])
if minutes <= 0:
return
with self._pause_lock:
self._pauses[provider] = (self._clock() + minutes * 60, reason[:200])
def _skip_reason(self, provider: str, settings: dict) -> str | None:
"""Por que o provedor não entra na cadeia (None = pronto). Não olha a pausa."""
conf = settings["providers"].get(provider) or {}
if not conf.get("enabled"):
return "desligada em Configurações → IA"
if not find_cli(provider):
return "CLI não encontrada"
if conf.get("authMode") == "apiKey" and not self.ai.has_key(provider):
return "modo chave de API sem chave no cofre"
return None
def fallback_chain(self) -> list[str]:
"""Ordem em que `ask` tenta as IAs: a escolhida no juiz primeiro, depois a `order` do painel, só as ligadas,
com CLI e (no modo chave) com chave; as em pausa são puladas. Reserva desligada: só a escolhida.
Se TODAS as prontas estiverem em pausa, elas voltam como último recurso (melhor tentar do que parar)."""
if not self.enabled:
return []
settings = self.ai.settings()
candidates = [self.provider]
if settings["fallback"]["enabled"]:
candidates += [p for p in settings["order"] if p != self.provider and p in AI_ENABLED]
ready = [p for p in candidates if self._skip_reason(p, settings) is None]
paused = self.pauses() if settings["fallback"]["enabled"] else {}
active = [p for p in ready if p not in paused]
return active or ready
def describe(self) -> dict: def describe(self) -> dict:
cmd = self.command() if self.enabled else None cmd = self.command() if self.enabled else None
settings = self.ai.settings()
primary_skip = self._skip_reason(self.provider, settings) if self.enabled else None
return {"provider": self.provider, "model": self.model if self.enabled else None, return {"provider": self.provider, "model": self.model if self.enabled else None,
"analystModel": (self.analyst_model or self.model) if self.enabled else None, "analystModel": (self.analyst_model or self.model) if self.enabled else None,
"available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None} "available": bool(cmd) if self.enabled else None, "path": cmd[-1] if cmd else None,
# Por que a escolhida não roda (desligada no painel, sem CLI, sem chave); None = pronta.
"unavailableReason": primary_skip,
"authMode": settings["providers"].get(self.provider, {}).get("authMode") if self.enabled else None,
"fallback": {"enabled": settings["fallback"]["enabled"],
"cooldownMin": settings["fallback"]["cooldownMin"],
"chain": self.fallback_chain()},
"pauses": [{"provider": p, "until": datetime.fromtimestamp(until, timezone.utc).isoformat(timespec="seconds"),
"reason": reason} for p, (until, reason) in sorted(self.pauses().items())]}
def models(self) -> dict: def models(self) -> dict:
return {"codex": codex_models(), "claude": CLAUDE_MODELS, "defaults": DEFAULT_MODELS} return {"codex": codex_models(), "claude": CLAUDE_MODELS, "gemini": GEMINI_MODELS, "defaults": DEFAULT_MODELS}
# ---------- usos # ---------- usos
def analyze(self, prompt: str, images: list[Path]) -> dict: def analyze(self, prompt: str, images: list[Path]) -> dict:
@@ -514,7 +747,8 @@ class Judge:
lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S, lo: float | None = None, hi: float | None = None, min_s: float = DEFAULT_MIN_S,
max_s: float = DEFAULT_MAX_S) -> Verdict: max_s: float = DEFAULT_MAX_S) -> Verdict:
data = self.ask(JUDGE_SYSTEM, prompt, VERDICT_SCHEMA, images or []) data = self.ask(JUDGE_SYSTEM, prompt, VERDICT_SCHEMA, images or [])
return _clean(data, start_s, end_s, f"{self.provider}:{self.model}", lo, hi, min_s, max_s) # Modelo de quem DE FATO respondeu (a reserva pode ter entrado no lugar da escolhida).
return _clean(data, start_s, end_s, self.responder(), lo, hi, min_s, max_s)
def scan(self, prompt: str, images: list[Path]) -> dict: def scan(self, prompt: str, images: list[Path]) -> dict:
data = self.ask(SCAN_SYSTEM, prompt, SCAN_SCHEMA, images) data = self.ask(SCAN_SYSTEM, prompt, SCAN_SCHEMA, images)
@@ -523,57 +757,105 @@ class Judge:
return data return data
def research_game(self, name: str, live_title: str = "", notes: list[str] | None = None) -> dict: def research_game(self, name: str, live_title: str = "", notes: list[str] | None = None) -> dict:
prompt = f"Categoria/jogo da live: {name}\nTítulo da live (pista extra): {live_title or '(nenhum)'}\n" prompt = f"Stream category / game: {name}\nStream title (extra hint): {live_title or '(none)'}\n"
if notes: if notes:
prompt += "Pedidos do usuário (respeite):\n" + "\n".join(f"- {n}" for n in notes) + "\n" prompt += "User requests (respect them; may be in Portuguese):\n" + "\n".join(f"- {n}" for n in notes) + "\n"
prompt += "Pesquise e devolva o perfil do jogo." prompt += "Research and return the game profile in English."
return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S) return self.ask(PROFILE_SYSTEM, prompt, PROFILE_SCHEMA, [], search=True, timeout=RESEARCH_TIMEOUT_S)
def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "", def refine_game(self, name: str, profile: dict, instruction: str, search: bool = True, section: str = "",
history: list[dict] | None = None) -> dict: history: list[dict] | None = None) -> dict:
"""Aplica um pedido do usuário ao perfil do jogo (acrescentar/corrigir/tirar) e devolve o perfil inteiro """Aplica um pedido do usuário ao perfil do jogo (acrescentar/corrigir/tirar) e devolve o perfil inteiro
mais `reply` (o que a IA fez, em 1–2 frases). `section` = campo em foco; `history` = conversa anterior.""" mais `reply` (o que a IA fez, em 1–2 frases). `section` = campo em foco; `history` = conversa anterior."""
prompt = f"Jogo: {name}\nPerfil ATUAL:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n" prompt = f"Game: {name}\nCURRENT profile:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
if section in PROFILE_SECTIONS: if section in PROFILE_SECTIONS:
prompt += f"SEÇÃO em foco: {section} ({PROFILE_SECTIONS[section]})\n" prompt += f"SECTION in focus: {section}\n"
if history: if history:
prompt += "Conversa até aqui:\n" + "\n".join( prompt += "Conversation so far:\n" + "\n".join(
f"{'Usuário' if h.get('role') == 'user' else 'IA'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n" f"{'User' if h.get('role') == 'user' else 'AI'}: {str(h.get('text', ''))[:400]}" for h in history[-8:]) + "\n"
prompt += f"PEDIDO do usuário:\n{instruction}\n\nDevolva o perfil completo atualizado e o reply." prompt += f"User REQUEST:\n{instruction}\n\nReturn the complete updated profile (English) and the reply (Portuguese)."
return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search, return self.ask(REFINE_SYSTEM, prompt, REFINE_SCHEMA, [], search=search,
timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S) timeout=RESEARCH_TIMEOUT_S if search else TIMEOUT_S)
def translate_game(self, profile: dict, target: str) -> dict:
"""Traduz o perfil inteiro (pt-BR <-> en-US), mesmo formato, sem busca. Nomes oficiais e hashtags ficam."""
language = TRANSLATE_TARGETS.get(target, target)
prompt = (f"Target language: {language}\nProfile JSON:\n{json.dumps(profile, ensure_ascii=False, indent=1)}\n\n"
"Return the translated profile.")
return self.ask(TRANSLATE_SYSTEM, prompt, PROFILE_SCHEMA, [], timeout=RESEARCH_TIMEOUT_S)
def detect_cam(self, images: list[Path]) -> dict: def detect_cam(self, images: list[Path]) -> dict:
return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images) return self.ask(CAM_SYSTEM, "Analise os frames anexados (mesma live, instantes diferentes).", CAM_SCHEMA, images)
# ---------- execução # ---------- execução
def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False, def ask(self, system: str, prompt: str, schema: dict, images: list[Path], *, search: bool = False,
timeout: int = TIMEOUT_S, model: str | None = None) -> dict: timeout: int = TIMEOUT_S, model: str | None = None) -> dict:
model = model or self.model """Chama a IA escolhida; se ela falhar por indisponibilidade, a próxima da cadeia de reserva (com o modelo
if self.provider == "codex": padrão DELA) e a que falhou fica em pausa. Erro de conteúdo (JSON inválido, campos faltando) não troca."""
return self._codex(system, prompt, schema, images, search, timeout, model) if not self.enabled:
if self.provider == "claude": raise JudgeError("IA desligada", unavailable=False)
return self._claude(system, prompt, schema, images, search, timeout, model) chain = self.fallback_chain()
raise JudgeError("IA desligada") if not chain:
why = self._skip_reason(self.provider, self.ai.settings()) or "nenhuma IA pronta"
raise JudgeError(f"{PROVIDER_NAMES[self.provider]} indisponível: {why} (veja Configurações → IA)",
unavailable=True)
fallback_on = self.ai.settings()["fallback"]["enabled"]
attempts: list[str] = []
for provider in chain:
use_model = (model or self.model) if provider == self.provider else DEFAULT_MODELS[provider]
try:
data = self._call(provider, system, prompt, schema, images, search, timeout, use_model)
except JudgeError as exc:
text = str(exc)
unavailable = exc.unavailable if exc.unavailable is not None else is_availability_error(text)
attempts.append(f"{provider}:{use_model}: {text}")
if not unavailable:
# Erro de conteúdo: a IA respondeu, o pedido é que não deu certo. Não troca de IA.
raise JudgeError(" · ".join(attempts) if len(attempts) > 1 else text, unavailable=False) from exc
if fallback_on:
self.pause(provider, text)
log.warning("IA %s indisponível (%s); tentando a reserva", provider, text[:160])
continue
raise JudgeError(text, unavailable=True) from exc
self._local.responder = f"{provider}:{use_model}"
if provider != self.provider:
log.info("respondido pela reserva %s:%s", provider, use_model)
return data
raise JudgeError("nenhuma IA respondeu — " + " · ".join(attempts)[:900], unavailable=True)
def _run(self, args: list[str], stdin: str, cwd: Path, timeout: int) -> subprocess.CompletedProcess: def _call(self, provider: str, system: str, prompt: str, schema: dict, images: list[Path], search: bool,
timeout: int, model: str) -> dict:
if provider == "codex":
return self._codex(system, prompt, schema, images, search, timeout, model)
if provider == "claude":
return self._claude(system, prompt, schema, images, search, timeout, model)
if provider == "gemini":
return self._gemini(system, prompt, schema, images, search, timeout, model)
raise JudgeError("IA desligada", unavailable=False)
def _run(self, args: list[str], stdin: str, cwd: Path, timeout: int, provider: str) -> subprocess.CompletedProcess:
# `env` por provedor: modo chave de API (só nesta chamada) ou sessão logada (doc/ia.md).
try: try:
result = subprocess.run(args, input=stdin.encode("utf-8"), capture_output=True, timeout=timeout, cwd=cwd, result = subprocess.run(args, input=stdin.encode("utf-8"), capture_output=True, timeout=timeout, cwd=cwd,
creationflags=NO_WINDOW) creationflags=NO_WINDOW, env=self.ai.provider_env(provider))
except subprocess.TimeoutExpired as exc: except subprocess.TimeoutExpired as exc:
raise JudgeError(f"a CLI passou de {timeout} s") from exc raise JudgeError(f"a CLI passou de {timeout} s (tempo esgotado)", unavailable=True) from exc
except OSError as exc: except OSError as exc:
raise JudgeError(f"não consegui rodar a CLI: {exc}") from exc raise JudgeError(f"não consegui rodar a CLI: {exc}", unavailable=True) from exc
if result.returncode != 0: if result.returncode != 0:
tail = result.stderr.decode("utf-8", errors="replace").strip().splitlines()[-2:] err = result.stderr.decode("utf-8", errors="replace").strip()
raise JudgeError(f"a CLI saiu com código {result.returncode}: {' | '.join(tail)[:300]}") out = result.stdout.decode("utf-8", errors="replace").strip()
tail = (err or out).splitlines()[-2:]
message = f"a CLI saiu com código {result.returncode}: {' | '.join(tail)[:300]}"
# Classifica pelo texto inteiro (o motivo pode estar antes das 2 últimas linhas, ou só no stdout).
raise JudgeError(message, unavailable=is_availability_error(err + "\n" + out))
return result return result
def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int, def _codex(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict: model: str) -> dict:
cmd = find_codex() cmd = find_codex()
if not cmd: if not cmd:
raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)") raise JudgeError("Codex CLI não encontrado (npm install -g @openai/codex; codex login)", unavailable=True)
self.workdir.mkdir(parents=True, exist_ok=True) self.workdir.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(dir=self.workdir) as tmp: with tempfile.TemporaryDirectory(dir=self.workdir) as tmp:
schema_file, out = Path(tmp) / "schema.json", Path(tmp) / "answer.json" schema_file, out = Path(tmp) / "schema.json", Path(tmp) / "answer.json"
@@ -594,17 +876,17 @@ class Judge:
args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral", args = [*cmd, *(["--search"] if search else []), "exec", "--skip-git-repo-check", "--ephemeral",
"--sandbox", "read-only", "-c", 'model_reasoning_effort="low"', *lean, "-m", model, *image_args, "--sandbox", "read-only", "-c", 'model_reasoning_effort="low"', *lean, "-m", model, *image_args,
"--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"] "--output-schema", str(schema_file), "-o", str(out), "-C", tmp, "-"]
self._run(args, stdin, Path(tmp), timeout) self._run(args, stdin, Path(tmp), timeout, "codex")
try: try:
return json.loads(out.read_text(encoding="utf-8")) return json.loads(out.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc: except (OSError, json.JSONDecodeError) as exc:
raise JudgeError("o Codex não devolveu o JSON pedido") from exc raise JudgeError("o Codex não devolveu o JSON pedido", unavailable=False) from exc
def _claude(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int, def _claude(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict: model: str) -> dict:
cmd = find_claude() cmd = find_claude()
if not cmd: if not cmd:
raise JudgeError("Claude Code CLI não encontrado") raise JudgeError("Claude Code CLI não encontrado", unavailable=True)
self.workdir.mkdir(parents=True, exist_ok=True) self.workdir.mkdir(parents=True, exist_ok=True)
tools = (["Read"] if images else []) + (["WebSearch", "WebFetch"] if search else []) tools = (["Read"] if images else []) + (["WebSearch", "WebFetch"] if search else [])
extra: list[str] = [] extra: list[str] = []
@@ -619,19 +901,76 @@ class Judge:
# --setting-sources: sem plugins e hooks do usuário (medido: 3,7 → 2,6 mil tokens fixos, 5,5 → 2,8 s). # --setting-sources: sem plugins e hooks do usuário (medido: 3,7 → 2,6 mil tokens fixos, 5,5 → 2,8 s).
"--no-session-persistence", "--strict-mcp-config", "--setting-sources", "project,local", "--no-session-persistence", "--strict-mcp-config", "--setting-sources", "project,local",
"--system-prompt", system] "--system-prompt", system]
result = self._run(args, prompt, self.workdir, timeout) result = self._run(args, prompt, self.workdir, timeout, "claude")
try: try:
envelope = json.loads(result.stdout.decode("utf-8", errors="replace")) envelope = json.loads(result.stdout.decode("utf-8", errors="replace"))
except json.JSONDecodeError as exc: except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu JSON") from exc raise JudgeError("o Claude não devolveu JSON", unavailable=False) from exc
if envelope.get("is_error"): if envelope.get("is_error"):
# Pode ser cota/login ("Credit balance is too low", "Not logged in"): o texto decide (unavailable=None).
raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}") raise JudgeError(f"o Claude terminou com erro: {str(envelope.get('result'))[:200]}")
data = envelope.get("structured_output") data = envelope.get("structured_output")
if not isinstance(data, dict): if not isinstance(data, dict):
try: try:
data = json.loads(envelope.get("result") or "") data = json.loads(envelope.get("result") or "")
except json.JSONDecodeError as exc: except json.JSONDecodeError as exc:
raise JudgeError("o Claude não devolveu o JSON pedido") from exc raise JudgeError("o Claude não devolveu o JSON pedido", unavailable=False) from exc
return data
def _gemini(self, system: str, prompt: str, schema: dict, images: list[Path], search: bool, timeout: int,
model: str) -> dict:
"""Gemini CLI headless (`-o json` → `{"response": "<texto>", "stats": …}`). Não há `--output-schema`: o
schema vai no texto e o JSON é extraído da resposta. `--approval-mode plan` = só leitura (a busca
google_web_search continua liberada). O corpo grande vai pela entrada padrão (o Gemini junta o `-p` ao
stdin), para não estourar o limite de linha de comando do Windows; no `-p` só a instrução curta e os
`@arquivo` das imagens.
Pasta de trabalho FORA do repositório (temp do sistema): o `@arquivo` respeita o .gitignore e `data/` é
ignorado no CenaForge; fora do repo o Gemini também não carrega GEMINI.md do projeto (menos tokens fixos).
As imagens são copiadas para lá com nomes curtos e referenciadas por caminho relativo."""
cmd = find_gemini()
if not cmd:
raise JudgeError("Gemini CLI não encontrado (npm install -g @google/gemini-cli; chave em Configurações → IA)",
unavailable=True)
with tempfile.TemporaryDirectory(prefix="cenaforge-gemini-") as tmp:
refs: list[str] = []
for i, img in enumerate(images):
src = Path(img)
name = f"frame-{i + 1:02d}{src.suffix.lower() or '.jpg'}"
try:
shutil.copyfile(src, Path(tmp) / name)
except OSError as exc:
raise JudgeError(f"não consegui preparar a imagem {src.name}: {exc}", unavailable=False) from exc
refs.append(f"@{name}")
stdin = (system + "\n\n---\n\n" + prompt
+ "\n\n---\n\nResponda SÓ com um objeto JSON válido (sem texto antes ou depois, sem cercas ```), "
"que siga exatamente este JSON Schema:\n" + json.dumps(schema, ensure_ascii=False))
short = ("Siga as instruções e os dados recebidos acima e responda só com o JSON pedido."
+ (" Use a busca na web (google_web_search) para confirmar os fatos." if search else
" Não use ferramentas."))
if refs:
short += " Frames anexados, na ordem: " + " ".join(refs)
args = [*cmd, "-p", short, "-o", "json", "--approval-mode", "plan", "--skip-trust", "-m", model]
result = self._run(args, stdin, Path(tmp), timeout, "gemini")
return parse_gemini_output(result.stdout.decode("utf-8", errors="replace"))
def parse_gemini_output(stdout: str) -> dict:
"""Envelope do `gemini -o json` → objeto JSON da resposta. Erro no envelope é classificado pelo texto (cota,
chave…); resposta sem JSON é erro de conteúdo."""
envelope = extract_json_object(stdout, fences=False)
if envelope is None:
raise JudgeError("o Gemini não devolveu JSON", unavailable=False)
error = envelope.get("error")
if error:
message = error.get("message") if isinstance(error, dict) else str(error)
raise JudgeError(f"o Gemini terminou com erro: {str(message or error)[:200]}")
response = envelope.get("response")
if not isinstance(response, str):
raise JudgeError("o Gemini não devolveu a resposta", unavailable=False)
data = extract_json_object(response)
if data is None:
raise JudgeError("o Gemini não devolveu o JSON pedido", unavailable=False)
return data return data
+116 -28
View File
@@ -19,7 +19,7 @@ from pathlib import Path
from . import capture, layout, media from . import capture, layout, media
from .config import REPO_ROOT from .config import REPO_ROOT
from .db import Database, loads, now from .db import Database, loads, now
from .judge import JudgeError from .judge import LANGUAGE_NAMES, JudgeError
from .scoring import timeline as timeline_series from .scoring import timeline as timeline_series
from .scoring import Word from .scoring import Word
from .sources import SourceError, parse_source from .sources import SourceError, parse_source
@@ -37,21 +37,43 @@ class UserError(Exception):
self.message, self.status = message, status self.message, self.status = message, status
# Idiomas aceitos em `language` (fonte e sessão). '' = padrão do serviço (CLIPPER_LANGUAGE). O painel oferece os mesmos.
LANGUAGES = tuple(LANGUAGE_NAMES)
def check_language(value: str | None) -> str | None:
"""None = não mexer; '' = voltar ao padrão; código válido = usar. Outra coisa é erro legível."""
if value is None:
return None
code = value.strip()
if code and code not in LANGUAGES:
raise UserError(f"Idioma inválido: use {', '.join(LANGUAGES)} (ou vazio para o padrão).")
return code
class ChannelIn(BaseModel): class ChannelIn(BaseModel):
url: str = Field(min_length=3, max_length=300) url: str = Field(min_length=3, max_length=300)
displayName: str | None = Field(default=None, max_length=60) displayName: str | None = Field(default=None, max_length=60)
monitor: bool = True monitor: bool = True
authorized: bool = False authorized: bool = False
language: str | None = Field(default=None, max_length=12)
class ChannelPatch(BaseModel): class ChannelPatch(BaseModel):
displayName: str | None = Field(default=None, max_length=60) displayName: str | None = Field(default=None, max_length=60)
monitor: bool | None = None monitor: bool | None = None
authorized: bool | None = None authorized: bool | None = None
language: str | None = Field(default=None, max_length=12)
class SessionIn(BaseModel): class SessionIn(BaseModel):
url: str = Field(min_length=3, max_length=300) url: str = Field(min_length=3, max_length=300)
language: str | None = Field(default=None, max_length=12)
class StopIn(BaseModel):
"""Parar à mão: `pauseMonitor` (padrão) deixa a fonte com o monitor pausado até você religar."""
pauseMonitor: bool = True
class ManualClipIn(BaseModel): class ManualClipIn(BaseModel):
@@ -62,7 +84,7 @@ class ManualClipIn(BaseModel):
class JudgeIn(BaseModel): class JudgeIn(BaseModel):
provider: Literal["codex", "claude", "off"] provider: Literal["codex", "claude", "gemini", "off"]
model: str = Field(default="", max_length=80, pattern=r"^[A-Za-z0-9._:-]*$") model: str = Field(default="", max_length=80, pattern=r"^[A-Za-z0-9._:-]*$")
minScore: float = Field(default=6, ge=0, le=10) minScore: float = Field(default=6, ge=0, le=10)
# Modelo do ANALISTA (1º juiz, vê os frames); vazio = o mesmo do editor. None = não mexer. # Modelo do ANALISTA (1º juiz, vê os frames); vazio = o mesmo do editor. None = não mexer.
@@ -80,9 +102,17 @@ class GameIn(BaseModel):
name: str = Field(min_length=1, max_length=120) name: str = Field(min_length=1, max_length=120)
class MissionIn(BaseModel):
name: str = Field(min_length=1, max_length=160)
chapter: str = Field(default="", max_length=120)
summary: str = Field(default="", max_length=500)
completion_triggers: list[str] = Field(default_factory=list, max_length=8)
class GameProfileIn(BaseModel): class GameProfileIn(BaseModel):
"""Perfil do jogo editado à mão no painel (mesmos campos que a IA devolve).""" """Perfil do jogo editado à mão no painel (mesmos campos que a IA devolve), em um dos dois idiomas."""
name: str = Field(default="", max_length=120) name: str = Field(default="", max_length=120)
aliases: list[str] = Field(default_factory=list, max_length=10) # outros nomes (categoria, abreviação)
summary: str = Field(default="", max_length=1500) summary: str = Field(default="", max_length=1500)
genre: str = Field(default="", max_length=120) genre: str = Field(default="", max_length=120)
mechanics: list[str] = Field(default_factory=list, max_length=30) mechanics: list[str] = Field(default_factory=list, max_length=30)
@@ -92,6 +122,14 @@ class GameProfileIn(BaseModel):
news: list[str] = Field(default_factory=list, max_length=30) news: list[str] = Field(default_factory=list, max_length=30)
hashtags: list[str] = Field(default_factory=list, max_length=20) # do jogo, a principal primeiro (app/hashtags.py) hashtags: list[str] = Field(default_factory=list, max_length=20) # do jogo, a principal primeiro (app/hashtags.py)
sources: list[str] = Field(default_factory=list, max_length=20) sources: list[str] = Field(default_factory=list, max_length=20)
missions: list[MissionIn] = Field(default_factory=list, max_length=120)
end_triggers: list[str] = Field(default_factory=list, max_length=12) # sinais gerais de fim de missão
class GameIn(BaseModel):
"""Jogo cadastrado pelo painel; `notes` = pista para a pesquisa (vira o 1º pedido guardado)."""
name: str = Field(min_length=2, max_length=120)
notes: str = Field(default="", max_length=1500)
class ChatTurnIn(BaseModel): class ChatTurnIn(BaseModel):
@@ -102,7 +140,8 @@ class ChatTurnIn(BaseModel):
class GameRefineIn(BaseModel): class GameRefineIn(BaseModel):
instruction: str = Field(min_length=3, max_length=1500) instruction: str = Field(min_length=3, max_length=1500)
search: bool = True # deixa a IA confirmar na web (mais lento); sem busca é quase instantâneo search: bool = True # deixa a IA confirmar na web (mais lento); sem busca é quase instantâneo
section: Literal["", "summary", "clip_worthy", "avoid", "mechanics", "news", "jargon", "hashtags", "sources"] = "" section: Literal["", "summary", "clip_worthy", "avoid", "mechanics", "news", "jargon", "hashtags", "sources",
"missions", "end_triggers", "aliases"] = ""
history: list[ChatTurnIn] = Field(default_factory=list, max_length=20) # conversa do chat da seção history: list[ChatTurnIn] = Field(default_factory=list, max_length=20) # conversa do chat da seção
@@ -143,6 +182,8 @@ def clip_view(row: dict) -> dict:
"aspect": row.get("aspect") or "vertical", "aspect": row.get("aspect") or "vertical",
"createdAt": row["created_at"], "updatedAt": row["updated_at"], "createdAt": row["created_at"], "updatedAt": row["updated_at"],
"channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"), "channelId": row.get("channel_id"), "platform": row.get("platform"), "sessionUrl": row.get("url"),
# Idioma da sessão (resolvido no SELECT: o da sessão ou o padrão do serviço). Ausente só em consultas antigas.
"language": row.get("language"),
# Editor de cortes: existe projeto de edição? (o export renderiza por ele; capa gerada no export) # Editor de cortes: existe projeto de edição? (o export renderiza por ele; capa gerada no export)
"edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"), "edit": ({"updatedAt": row["edit_updated_at"], "exportedAt": row.get("edit_exported_at"), "cover": row.get("edit_cover"),
"origin": row.get("edit_origin")} "origin": row.get("edit_origin")}
@@ -174,14 +215,19 @@ def session_view(row: dict, engine: Engine) -> dict:
# O que a captura gravou de fato (1º bloco de cada execução): qualidade pedida, largura, altura, qps, codec, # O que a captura gravou de fato (1º bloco de cada execução): qualidade pedida, largura, altura, qps, codec,
# kbps, GB/h e `mixed` (retomada em outra resolução). None = sessão antiga ou ainda sem bloco. # kbps, GB/h e `mixed` (retomada em outra resolução). None = sessão antiga ou ainda sem bloco.
"capture": loads(row.get("capture_json"), None), "capture": loads(row.get("capture_json"), None),
# Idioma falado na live (resolvido: o da sessão, senão o padrão do serviço).
"language": row.get("language") or engine.settings.language,
} }
def channel_view(row: dict) -> dict: def channel_view(row: dict, default_language: str = "") -> dict:
return { return {
"id": row["id"], "platform": row["platform"], "channel": row["channel"], "url": row["url"], "id": row["id"], "platform": row["platform"], "channel": row["channel"], "url": row["url"],
"displayName": row["display_name"], "monitor": bool(row["monitor"]), "authorized": bool(row["authorized"]), "displayName": row["display_name"], "monitor": bool(row["monitor"]), "authorized": bool(row["authorized"]),
"lastCheckAt": row["last_check_at"], "lastStatus": row["last_status"], "createdAt": row["created_at"], "lastCheckAt": row["last_check_at"], "lastStatus": row["last_status"], "createdAt": row["created_at"],
# Monitor pausado porque você parou uma sessão à mão (não grava de novo até religar).
"monitorPausedAt": row.get("monitor_paused_at"), "monitorPausedBySession": row.get("monitor_paused_session"),
"language": row.get("language") or default_language,
} }
@@ -386,27 +432,62 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
engine.intel.set_game(session_id, body.name.strip(), "user") engine.intel.set_game(session_id, body.name.strip(), "user")
return session_view(_session(session_id), engine) return session_view(_session(session_id), engine)
def game_view(g: dict) -> dict:
# `profile` = português (o painel mostra); `profileAi` = inglês (vai nos prompts; null = jogo antigo, a IA
# usa `profile`). Contrato em doc/clipador/JOGOS.md.
return {"id": g["id"], "name": g["name"], "status": g["status"], "error": g["error"],
"model": g["model"], "researchedAt": g["researched_at"], "editedAt": g.get("edited_at"),
"notes": loads(g.get("notes_json"), []), "profile": loads(g["profile_json"], None),
"profileAi": loads(g.get("profile_ai_json"), None), "aiLanguage": "en-US",
"translatedAt": g.get("translated_at"), "aliases": loads(g.get("aliases_json"), [])}
@app.get("/v1/games") @app.get("/v1/games")
def list_games(): def list_games():
return {"games": [{"id": g["id"], "name": g["name"], "status": g["status"], "error": g["error"], return {"games": [game_view(g) for g in db.all("SELECT * FROM games ORDER BY name")]}
"model": g["model"], "researchedAt": g["researched_at"], "editedAt": g.get("edited_at"),
"notes": loads(g.get("notes_json"), []), "profile": loads(g["profile_json"], None)} @app.post("/v1/games", status_code=201)
for g in db.all("SELECT * FROM games ORDER BY name")]} def add_game(body: GameIn):
"""Cadastra um jogo e pesquisa em segundo plano (o jogo aparece `pending` até a pesquisa terminar)."""
try:
gid = engine.intel.add_game(body.name, body.notes)
except LookupError as exc:
raise UserError(str(exc), 409) from exc
except ValueError as exc:
raise UserError(str(exc)) from exc
return {**list_games(), "id": gid}
@app.delete("/v1/games/{game_id}")
def delete_game(game_id: str):
try:
engine.intel.delete_game(game_id)
except JudgeError as exc:
raise UserError(str(exc), 404) from exc
return list_games()
@app.post("/v1/games/{game_id}/research") @app.post("/v1/games/{game_id}/research")
def research_game(game_id: str): def research_game(game_id: str):
"""Pesquisa (de novo) o jogo na web pela IA. Leva de 15 s a alguns minutos. Os pedidos guardados entram junto.""" """Pesquisa (de novo) o jogo na web pela IA, em inglês, e traduz para português. Leva de 15 s a alguns minutos.
Os pedidos guardados entram junto."""
try: try:
engine.intel.research(game_id) engine.intel.research(game_id)
except JudgeError as exc: except JudgeError as exc:
raise UserError(str(exc)) from exc raise UserError(str(exc)) from exc
return list_games() return list_games()
@app.put("/v1/games/{game_id}") @app.post("/v1/games/{game_id}/translate")
def put_game_profile(game_id: str, body: GameProfileIn): def translate_game(game_id: str):
"""Grava o perfil editado à mão. A IA passa a usar na hora.""" """Gera a versão da IA (inglês) a partir da portuguesa (jogos de antes dos perfis bilíngues)."""
try: try:
engine.intel.save_profile(game_id, body.model_dump()) engine.intel.translate(game_id)
except JudgeError as exc:
raise UserError(str(exc)) from exc
return list_games()
@app.put("/v1/games/{game_id}")
def put_game_profile(game_id: str, body: GameProfileIn, lang: Literal["pt", "en"] = "pt"):
"""Grava o perfil editado à mão no idioma `lang` e traduz para o outro. A IA passa a usar na hora."""
try:
engine.intel.save_profile(game_id, body.model_dump(), lang)
except JudgeError as exc: except JudgeError as exc:
raise UserError(str(exc), 404) from exc raise UserError(str(exc), 404) from exc
return list_games() return list_games()
@@ -440,7 +521,7 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
# ---------- canais # ---------- canais
@app.get("/v1/channels") @app.get("/v1/channels")
def list_channels(): def list_channels():
return {"channels": [channel_view(r) for r in db.all("SELECT * FROM channels ORDER BY display_name")]} return {"channels": [channel_view(r, settings.language) for r in db.all("SELECT * FROM channels ORDER BY display_name")]}
@app.post("/v1/channels", status_code=201) @app.post("/v1/channels", status_code=201)
def create_channel(body: ChannelIn): def create_channel(body: ChannelIn):
@@ -449,22 +530,27 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
raise UserError("Para monitorar, use o link do canal (ex.: twitch.tv/alanzoka), não de um vídeo.") raise UserError("Para monitorar, use o link do canal (ex.: twitch.tv/alanzoka), não de um vídeo.")
if db.get("SELECT 1 FROM channels WHERE id = ?", source.channel_id): if db.get("SELECT 1 FROM channels WHERE id = ?", source.channel_id):
raise UserError("Esse canal já está na lista.", 409) raise UserError("Esse canal já está na lista.", 409)
db.run("INSERT INTO channels (id, platform, channel, url, display_name, monitor, authorized, created_at)" language = check_language(body.language) or ""
" VALUES (?, ?, ?, ?, ?, ?, ?, ?)", db.run("INSERT INTO channels (id, platform, channel, url, display_name, monitor, authorized, created_at, language)"
" VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
source.channel_id, source.platform, source.channel, source.url, source.channel_id, source.platform, source.channel, source.url,
(body.displayName or source.channel.lstrip("@")).strip(), int(body.monitor), int(body.authorized), now()) (body.displayName or source.channel.lstrip("@")).strip(), int(body.monitor), int(body.authorized), now(), language)
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", source.channel_id)) return channel_view(db.get("SELECT * FROM channels WHERE id = ?", source.channel_id), settings.language)
@app.patch("/v1/channels/{channel_id}") @app.patch("/v1/channels/{channel_id}")
def update_channel(channel_id: str, body: ChannelPatch): def update_channel(channel_id: str, body: ChannelPatch):
row = db.get("SELECT * FROM channels WHERE id = ?", channel_id) row = db.get("SELECT * FROM channels WHERE id = ?", channel_id)
if not row: if not row:
raise UserError("Canal não encontrado.", 404) raise UserError("Canal não encontrado.", 404)
db.run("UPDATE channels SET display_name = ?, monitor = ?, authorized = ? WHERE id = ?", language = check_language(body.language)
db.run("UPDATE channels SET display_name = ?, monitor = ?, authorized = ?, language = ? WHERE id = ?",
(body.displayName or row["display_name"]).strip(), (body.displayName or row["display_name"]).strip(),
int(body.monitor if body.monitor is not None else row["monitor"]), int(body.monitor if body.monitor is not None else row["monitor"]),
int(body.authorized if body.authorized is not None else row["authorized"]), channel_id) int(body.authorized if body.authorized is not None else row["authorized"]),
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", channel_id)) language if language is not None else row.get("language") or "", channel_id)
if body.monitor is True:
engine.clear_monitor_pause(channel_id) # "Religar" no painel
return channel_view(db.get("SELECT * FROM channels WHERE id = ?", channel_id), settings.language)
@app.delete("/v1/channels/{channel_id}", status_code=204) @app.delete("/v1/channels/{channel_id}", status_code=204)
def delete_channel(channel_id: str): def delete_channel(channel_id: str):
@@ -491,8 +577,9 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
def create_session(body: SessionIn): def create_session(body: SessionIn):
source = parse_source(body.url) source = parse_source(body.url)
channel = db.get("SELECT id FROM channels WHERE id = ?", source.channel_id) if source.channel else None channel = db.get("SELECT id FROM channels WHERE id = ?", source.channel_id) if source.channel else None
language = check_language(body.language)
try: try:
session_id = engine.start_session(body.url, channel["id"] if channel else None) session_id = engine.start_session(body.url, channel["id"] if channel else None, language=language)
except RuntimeError as exc: except RuntimeError as exc:
raise UserError(str(exc)) from exc raise UserError(str(exc)) from exc
return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine) return session_view(db.get("SELECT * FROM sessions WHERE id = ?", session_id), engine)
@@ -533,8 +620,9 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
return clip_view(_clip(int(cur.lastrowid))) return clip_view(_clip(int(cur.lastrowid)))
@app.post("/v1/sessions/{session_id}/stop") @app.post("/v1/sessions/{session_id}/stop")
def stop_session(session_id: int): def stop_session(session_id: int, body: StopIn | None = None):
engine.stop_session(session_id) """Para a gravação à mão. Sem corpo (ou `pauseMonitor: true`): a fonte fica com o monitor pausado até religar."""
engine.stop_session(session_id, pause_monitor=body.pauseMonitor if body else True)
return {"ok": True} return {"ok": True}
@app.post("/v1/sessions/{session_id}/resume") @app.post("/v1/sessions/{session_id}/resume")
@@ -566,8 +654,8 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
channel: str | None = None, ids: str | None = None): channel: str | None = None, ids: str | None = None):
"""Filtros opcionais (todos separados por vírgula): `status`, `channel` (fontes, ex.: twitch-alanzoka) e `ids`. """Filtros opcionais (todos separados por vírgula): `status`, `channel` (fontes, ex.: twitch-alanzoka) e `ids`.
O despachante de publicação do painel usa `channel` + `status=ready,approved` e `ids` para conferir a fila.""" O despachante de publicação do painel usa `channel` + `status=ready,approved` e `ids` para conferir a fila."""
sql = "SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE 1 = 1" sql = "SELECT c.*, s.channel_id, s.platform, s.url, COALESCE(NULLIF(s.language, ''), ?) AS language, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE 1 = 1"
params: list = [] params: list = [settings.language]
if status: if status:
sql += " AND c.status IN (" + ",".join("?" * len(status.split(","))) + ")" sql += " AND c.status IN (" + ",".join("?" * len(status.split(","))) + ")"
params += status.split(",") params += status.split(",")
@@ -590,7 +678,7 @@ def create_app(settings: Settings | None = None, engine: Engine | None = None, s
return {"clips": [clip_view(r) for r in db.all(sql, *params)]} return {"clips": [clip_view(r) for r in db.all(sql, *params)]}
def _clip(clip_id: int) -> dict: def _clip(clip_id: int) -> dict:
row = db.get("SELECT c.*, s.channel_id, s.platform, s.url, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE c.id = ?", clip_id) row = db.get("SELECT c.*, s.channel_id, s.platform, s.url, COALESCE(NULLIF(s.language, ''), ?) AS language, e.updated_at AS edit_updated_at, e.exported_at AS edit_exported_at, e.cover AS edit_cover, e.origin AS edit_origin FROM clips c JOIN sessions s ON s.id = c.session_id LEFT JOIN edits e ON e.clip_id = c.id WHERE c.id = ?", settings.language, clip_id)
if not row: if not row:
raise UserError("Corte não encontrado.", 404) raise UserError("Corte não encontrado.", 404)
return row return row
+217
View File
@@ -0,0 +1,217 @@
{
"name": "Grand Theft Auto VI",
"aliases": ["GTA 6", "GTA VI", "GTA6", "GTAVI", "Grand Theft Auto 6"],
"researchedAt": "2026-11-18T12:00:00Z",
"sources": [
"https://www.rockstargames.com/VI",
"https://www.forbes.com/sites/erikkain/2026/11/16/gta-6-release-date-time-ps5-xbox-series-x-download-size-day-one-update/",
"https://hothardware.com/news/gta-6-extended-look-reveals-story-missions-and-massive-map-details",
"https://lfcarry.com/guides/gta-6-chapter-list-walkthrough",
"https://www.gtabase.com/articles/gta-6/gta-6-previews-recap-all-new-gameplay-features-revealed",
"https://allthings.how/gta-6-wanted-system-explained-how-heat-builds-and-how-you-lose-it/",
"https://www.redbull.com/int-en/gta-6-gameplay-details",
"https://www.gfinityesports.com/article/gta-6-map-guide-every-confirmed-location-in-leonida"
],
"profileAi": {
"name": "Grand Theft Auto VI",
"aliases": ["GTA 6", "GTA VI", "GTA6", "GTAVI", "Grand Theft Auto 6"],
"genre": "Open-world action-adventure / crime",
"summary": "Rockstar's open-world crime game set in the state of Leonida (a Florida parody), centered on Vice City. You play as Jason Duval and Lucia Caminos, a criminal couple who start with small robberies and work up to bigger jobs, switching between them (even mid-action). Released November 19, 2026 on PS5 and Xbox Series X|S.",
"mechanics": [
"Two playable protagonists (Jason and Lucia), switchable at any time, including mid-chase",
"Robberies of stores, diners and gas stations early on; bigger heists later (bank job at Sinfrontera National Bank shown in trailers)",
"Wanted level with up to six stars plus a Heat system: police only react to reported crimes (witness or alarm); the HUD shows what cops know (vehicle, outfit, face, weapons, CCTV)",
"Losing the cops: break line of sight, change outfit or vehicle, split Jason and Lucia up, wear masks before crimes",
"Carjacking with a slim jim instead of breaking windows; low-end cars and basic locks at the start",
"Phone and in-game social media (calls, texts, feeds); the couple can meet up for crimes or dates in free roam",
"Huge map: Vice City, Leonida Keys, Grassrivers, Port Gellhorn, Ambrosia, Mount Kalaga; wildlife including alligators",
"Activities: hunting and fishing, nightlife, gym, side jobs and strangers"
],
"clip_worthy": [
"Heist or store robbery going wrong: alarm, hostage, partner panics, cops arrive early",
"Wild police chase escalating to 5-6 stars, ending in a crash or a lucky escape",
"Switching between Jason and Lucia at the perfect moment in a chase or shootout",
"Alligator, wildlife or 'Florida Man' NPC chaos (bizarre locals, viral-style street scenes)",
"Physics and ragdoll fails: car flips, boat or jet ski crashes, falling off buildings",
"Streamer's first reaction to a big reveal: Vice City skyline, a story twist, a famous character",
"Mission climax: last-second escape, the payout being counted, or a dramatic WASTED/BUSTED right at the end",
"Funny dialogue between Jason and Lucia or with NPCs (Cal, Boobie Ike, Raul)",
"Graphics and realism 'wow' moments the chat spams about (crowds, weather, beach)",
"Launch-day glitches and bugs (cars in walls, T-poses, NPC weirdness)"
],
"avoid": [
"Menus, map browsing, wardrobe and shopping screens",
"Long cutscenes with no reaction from the streamer (also copyright-heavy)",
"Driving across the map with nothing happening",
"Loading screens, settings and install or update talk",
"Repetitive gunfights with no fail, escape or joke"
],
"jargon": [
"Leonida (the state), Vice City / VC, the Keys",
"Jason, Lucia (Lu), Cal, Boobie Ike, Raul Bautista, Brian, Dre'Quan, Real Dimez",
"estrelas / stars / procurado / wanted, heat, '6 estrelas'",
"WASTED / BUSTED",
"assalto / roubo / golpe / heist",
"boca / stash house",
"Florida Man",
"chave micha / slim jim",
"trocar de personagem / switch",
"GTA Online / GTAO (when online launches)"
],
"news": [
"Nov 2026: launch on November 19, 2026 (midnight local time, rolling by region), PS5 and Xbox Series X|S only; no PC version announced",
"Nov 2026: download of up to ~212 GB with a day-one update",
"Nov 2025: release moved from May 26, 2026 to November 19, 2026",
"2026: the 'An Extended Look' gameplay video showed story mission openings, robberies and the wanted/Heat HUD",
"May 2025: Trailer 2 introduced Jason, Lucia and the supporting cast"
],
"hashtags": ["#GTA6", "#GTAVI", "#GrandTheftAutoVI", "#ViceCity", "#GTA6Brasil", "#Rockstar"],
"sources": [
"https://www.rockstargames.com/VI",
"https://www.forbes.com/sites/erikkain/2026/11/16/gta-6-release-date-time-ps5-xbox-series-x-download-size-day-one-update/",
"https://hothardware.com/news/gta-6-extended-look-reveals-story-missions-and-massive-map-details",
"https://lfcarry.com/guides/gta-6-chapter-list-walkthrough",
"https://www.gtabase.com/articles/gta-6/gta-6-previews-recap-all-new-gameplay-features-revealed",
"https://allthings.how/gta-6-wanted-system-explained-how-heat-builds-and-how-you-lose-it/",
"https://www.redbull.com/int-en/gta-6-gameplay-details",
"https://www.gfinityesports.com/article/gta-6-map-guide-every-confirmed-location-in-leonida"
],
"missions": [
{
"name": "Boobie Ike stash pickup (descriptive name, not official)",
"chapter": "Shown in 'An Extended Look' (pre-launch)",
"summary": "A drug pickup for Boobie Ike that turns into a police raid.",
"completion_triggers": ["Escaping the raid and losing the wanted stars", "Dropping the package at Boobie's spot or the end-of-mission cutscene", "Mission complete banner or results screen"]
},
{
"name": "Raul Bautista getaway (descriptive name, not official)",
"chapter": "Shown in 'An Extended Look' (pre-launch)",
"summary": "A getaway job for the professional robber Raul Bautista.",
"completion_triggers": ["Reaching the drop-off or safe point with the police lost", "Payout or split shown on screen", "Mission complete banner or results screen"]
},
{
"name": "Skyscraper security job (descriptive name, not official)",
"chapter": "Shown in 'An Extended Look' (pre-launch)",
"summary": "A security job that turns into a hostage situation inside a skyscraper.",
"completion_triggers": ["Hostage standoff resolved (shootout ends or a deal is made)", "Leaving the building or the escape cutscene", "Mission complete banner or results screen"]
},
{
"name": "Rooftop party with a wealthy employer (descriptive name, not official)",
"chapter": "Shown in 'An Extended Look' (pre-launch)",
"summary": "Jason and Lucia meet a very wealthy, dubious employer at a rooftop party.",
"completion_triggers": ["The conversation or cutscene with the employer ends", "A new contact appears on the phone", "Mission complete banner"]
}
],
"end_triggers": [
"Mission complete/passed banner or a results screen with time, accuracy or payout",
"Robbery payout or money split counted on screen",
"Wanted stars disappear (cops lost) right after the getaway",
"Arriving at the drop-off, hideout or safehouse marker and the car stops",
"Ending cutscene starts (camera leaves gameplay, letterbox bars)",
"Failure: WASTED or BUSTED screen, or 'mission failed' with a retry prompt",
"Phone call or text from the contact wrapping up the job",
"Streamer says 'passou', 'consegui', 'acabou a missão' or celebrates; chat spams GG/W"
]
},
"profile": {
"name": "Grand Theft Auto VI",
"aliases": ["GTA 6", "GTA VI", "GTA6", "GTAVI", "Grand Theft Auto 6"],
"genre": "Ação e aventura em mundo aberto / crime",
"summary": "Jogo de crime em mundo aberto da Rockstar no estado de Leonida (paródia da Flórida), com Vice City no centro. Você joga com Jason Duval e Lucia Caminos, um casal de criminosos que começa com roubos pequenos e sobe para trabalhos maiores, trocando entre os dois (até no meio da ação). Lançado em 19 de novembro de 2026 para PS5 e Xbox Series X|S.",
"mechanics": [
"Dois protagonistas jogáveis (Jason e Lucia), com troca a qualquer hora, inclusive no meio de uma perseguição",
"Roubos de lojas, lanchonetes e postos no começo; golpes maiores depois (assalto ao Sinfrontera National Bank nos trailers)",
"Procurado com até seis estrelas mais o sistema de Heat: a polícia só reage a crime denunciado (testemunha ou alarme); o HUD mostra o que a polícia sabe (carro, roupa, rosto, armas, câmeras)",
"Despistar a polícia: sair do campo de visão, trocar roupa ou carro, separar Jason e Lucia, usar máscara antes do crime",
"Roubo de carro com chave micha (slim jim) em vez de quebrar o vidro; carros fracos e trancas simples no início",
"Celular e redes sociais do jogo (ligações, mensagens, feeds); o casal pode se encontrar para crimes ou encontros no mundo aberto",
"Mapa enorme: Vice City, Leonida Keys, Grassrivers, Port Gellhorn, Ambrosia, Mount Kalaga; fauna com jacarés",
"Atividades: caça e pesca, vida noturna, academia, trabalhos paralelos e personagens aleatórios"
],
"clip_worthy": [
"Assalto ou roubo de loja dando errado: alarme, refém, parceiro em pânico, polícia chegando antes",
"Perseguição policial que escala para 5-6 estrelas e termina em batida ou fuga na sorte",
"Troca entre Jason e Lucia no momento perfeito de uma perseguição ou tiroteio",
"Caos com jacaré, bichos ou NPC 'Florida Man' (moradores bizarros, cenas de rua tipo viral)",
"Falhas de física: carro capotando, lancha ou jet ski batendo, queda de prédio",
"Primeira reação do streamer a algo grande: horizonte de Vice City, reviravolta da história, personagem famoso",
"Clímax de missão: fuga no último segundo, o dinheiro sendo contado, ou um WASTED/BUSTED bem no final",
"Diálogo engraçado entre Jason e Lucia ou com NPCs (Cal, Boobie Ike, Raul)",
"Momentos de 'olha esse gráfico' que o chat comenta (multidão, clima, praia)",
"Bugs e glitches de lançamento (carro na parede, T-pose, NPC estranho)"
],
"avoid": [
"Menus, mapa, guarda-roupa e telas de compra",
"Cutscenes longas sem reação do streamer (e com risco de direitos autorais)",
"Dirigir pelo mapa sem acontecer nada",
"Telas de carregamento, configurações e papo de instalação ou atualização",
"Tiroteio repetitivo sem falha, fuga ou piada"
],
"jargon": [
"Leonida (o estado), Vice City / VC, the Keys",
"Jason, Lucia (Lu), Cal, Boobie Ike, Raul Bautista, Brian, Dre'Quan, Real Dimez",
"estrelas / stars / procurado / wanted, heat, '6 estrelas'",
"WASTED / BUSTED",
"assalto / roubo / golpe / heist",
"boca / stash house",
"Florida Man",
"chave micha / slim jim",
"trocar de personagem / switch",
"GTA Online / GTAO (quando o online sair)"
],
"news": [
"nov/2026: lançamento em 19 de novembro de 2026 (meia-noite no horário local, por região), só PS5 e Xbox Series X|S; sem versão de PC anunciada",
"nov/2026: download de até ~212 GB com atualização do primeiro dia",
"nov/2025: lançamento adiado de 26 de maio de 2026 para 19 de novembro de 2026",
"2026: o vídeo 'An Extended Look' mostrou o início de missões da história, roubos e o HUD de procurado/Heat",
"mai/2025: o Trailer 2 apresentou Jason, Lucia e o elenco de apoio"
],
"hashtags": ["#GTA6", "#GTAVI", "#GrandTheftAutoVI", "#ViceCity", "#GTA6Brasil", "#Rockstar"],
"sources": [
"https://www.rockstargames.com/VI",
"https://www.forbes.com/sites/erikkain/2026/11/16/gta-6-release-date-time-ps5-xbox-series-x-download-size-day-one-update/",
"https://hothardware.com/news/gta-6-extended-look-reveals-story-missions-and-massive-map-details",
"https://lfcarry.com/guides/gta-6-chapter-list-walkthrough",
"https://www.gtabase.com/articles/gta-6/gta-6-previews-recap-all-new-gameplay-features-revealed",
"https://allthings.how/gta-6-wanted-system-explained-how-heat-builds-and-how-you-lose-it/",
"https://www.redbull.com/int-en/gta-6-gameplay-details",
"https://www.gfinityesports.com/article/gta-6-map-guide-every-confirmed-location-in-leonida"
],
"missions": [
{
"name": "Boobie Ike stash pickup (nome descritivo, não oficial)",
"chapter": "Mostrada em 'An Extended Look' (antes do lançamento)",
"summary": "Uma coleta de droga para o Boobie Ike que vira uma batida policial.",
"completion_triggers": ["Fugir da batida e perder as estrelas", "Entregar a carga no ponto do Boobie ou a cutscene de fim", "Banner de missão concluída ou tela de resultado"]
},
{
"name": "Raul Bautista getaway (nome descritivo, não oficial)",
"chapter": "Mostrada em 'An Extended Look' (antes do lançamento)",
"summary": "Uma fuga para o assaltante profissional Raul Bautista.",
"completion_triggers": ["Chegar ao ponto de entrega com a polícia despistada", "Dinheiro ou divisão aparecendo na tela", "Banner de missão concluída ou tela de resultado"]
},
{
"name": "Skyscraper security job (nome descritivo, não oficial)",
"chapter": "Mostrada em 'An Extended Look' (antes do lançamento)",
"summary": "Um trabalho de segurança que vira uma situação com reféns num arranha-céu.",
"completion_triggers": ["Impasse com reféns resolvido (fim do tiroteio ou acordo)", "Saída do prédio ou cutscene de fuga", "Banner de missão concluída ou tela de resultado"]
},
{
"name": "Rooftop party with a wealthy employer (nome descritivo, não oficial)",
"chapter": "Mostrada em 'An Extended Look' (antes do lançamento)",
"summary": "Jason e Lucia conhecem um patrão muito rico e suspeito numa festa na cobertura.",
"completion_triggers": ["A conversa ou cutscene com o patrão termina", "Um contato novo aparece no celular", "Banner de missão concluída"]
}
],
"end_triggers": [
"Banner de missão concluída ou tela de resultado com tempo, precisão ou pagamento",
"Dinheiro do roubo ou a divisão sendo contados na tela",
"As estrelas de procurado somem (polícia despistada) logo depois da fuga",
"Chegada ao marcador de entrega, esconderijo ou casa e o carro para",
"Começa a cutscene final (a câmera sai do gameplay, faixas pretas)",
"Falha: tela WASTED ou BUSTED, ou 'missão falhou' com opção de tentar de novo",
"Ligação ou mensagem do contato encerrando o trabalho",
"Streamer fala 'passou', 'consegui', 'acabou a missão' ou comemora; chat enche de GG/W"
]
}
}
+48 -9
View File
@@ -67,11 +67,12 @@ class VoiceClient:
except httpx.HTTPError: except httpx.HTTPError:
return False return False
def transcribe(self, wav: bytes, idempotency_key: str) -> list[Word]: def transcribe(self, wav: bytes, idempotency_key: str, language: str | None = None) -> list[Word]:
"""`language` = idioma da sessão (fonte gringa); vazio/None = o padrão do serviço (CLIPPER_LANGUAGE)."""
if not self.configured: if not self.configured:
raise RuntimeError("serviço de voz não instalado") raise RuntimeError("serviço de voz não instalado")
headers = { headers = {
"X-Service-Key": self.key or "", "Content-Type": "audio/wav", "X-Language": self.language, "X-Service-Key": self.key or "", "Content-Type": "audio/wav", "X-Language": language or self.language,
"X-Detail": "words", "X-Idempotency-Key": idempotency_key, "X-Detail": "words", "X-Idempotency-Key": idempotency_key,
} }
response = httpx.post(f"{self.url}/v1/transcribe", content=wav, headers=headers, timeout=180) response = httpx.post(f"{self.url}/v1/transcribe", content=wav, headers=headers, timeout=180)
@@ -462,6 +463,9 @@ class Engine:
self.db.run("UPDATE sessions SET status = 'starting', ended_at = NULL, error = NULL WHERE id = ?", session_id) self.db.run("UPDATE sessions SET status = 'starting', ended_at = NULL, error = NULL WHERE id = ?", session_id)
capture = Capture(self, session_id, source, REPO_ROOT / session["dir"], start_idx=(last + 1) if last is not None else 0) capture = Capture(self, session_id, source, REPO_ROOT / session["dir"], start_idx=(last + 1) if last is not None else 0)
self.captures[session_id] = capture self.captures[session_id] = capture
if session["channel_id"] and not only_if_status:
# Você retomou pelo painel: a fonte volta a ser monitorada (a retomada automática não mexe na pausa).
self.clear_monitor_pause(session["channel_id"])
capture.start() capture.start()
return True return True
@@ -513,7 +517,9 @@ class Engine:
return self.judge_config() return self.judge_config()
# ---------- sessões # ---------- sessões
def start_session(self, url: str, channel_id: str | None = None) -> int: def start_session(self, url: str, channel_id: str | None = None, language: str | None = None) -> int:
"""Começa a gravar (live) ou baixar (VOD). `language` = idioma falado; vazio herda o da fonte ('' = padrão).
Gravar à mão uma fonte com o monitor pausado religa o monitor (você ligou de propósito)."""
source = parse_source(url) source = parse_source(url)
if not self.settings.streamlink or not self.settings.ffmpeg: if not self.settings.streamlink or not self.settings.ffmpeg:
raise RuntimeError("Streamlink ou FFmpeg não encontrados: rode o setup.bat.") raise RuntimeError("Streamlink ou FFmpeg não encontrados: rode o setup.bat.")
@@ -521,10 +527,14 @@ class Engine:
active = self.db.get("SELECT id FROM sessions WHERE url = ? AND status IN ('starting', 'recording')", source.url) active = self.db.get("SELECT id FROM sessions WHERE url = ? AND status IN ('starting', 'recording')", source.url)
if active: if active:
return active["id"] return active["id"]
channel = self.db.get("SELECT language FROM channels WHERE id = ?", channel_id) if channel_id else None
cur = self.db.run( cur = self.db.run(
"INSERT INTO sessions (channel_id, platform, kind, url, status, dir, started_at) VALUES (?, ?, ?, ?, 'starting', '', ?)", "INSERT INTO sessions (channel_id, platform, kind, url, status, dir, started_at, language)"
channel_id, source.platform, source.kind, source.url, now()) " VALUES (?, ?, ?, ?, 'starting', '', ?, ?)",
channel_id, source.platform, source.kind, source.url, now(), (language or (channel or {}).get("language") or "").strip())
session_id = int(cur.lastrowid) session_id = int(cur.lastrowid)
if channel_id:
self.clear_monitor_pause(channel_id)
workdir = self.settings.data_dir / "sessions" / str(session_id) workdir = self.settings.data_dir / "sessions" / str(session_id)
self.db.run("UPDATE sessions SET dir = ? WHERE id = ?", rel(workdir), session_id) self.db.run("UPDATE sessions SET dir = ? WHERE id = ?", rel(workdir), session_id)
capture = Capture(self, session_id, source, workdir) capture = Capture(self, session_id, source, workdir)
@@ -548,12 +558,28 @@ class Engine:
if session: if session:
self.intel.check_game(session, force=True) self.intel.check_game(session, force=True)
def stop_session(self, session_id: int) -> None: def stop_session(self, session_id: int, *, pause_monitor: bool = True) -> None:
"""Para a gravação. `pause_monitor` (padrão): a fonte monitorada fica com o monitor PAUSADO — senão, 60 s depois
o monitor abriria uma sessão nova, porque a live continua no ar (reclamação do dono, 18/11/2026). A queda de
live (captura cai sozinha) não passa por aqui e continua retomando na mesma sessão (`keep_live`)."""
with self.lock: with self.lock:
capture = self.captures.get(session_id) capture = self.captures.get(session_id)
if capture: if capture:
self.db.run("UPDATE sessions SET status = 'stopped' WHERE id = ? AND status IN ('starting', 'recording')", session_id) self.db.run("UPDATE sessions SET status = 'stopped' WHERE id = ? AND status IN ('starting', 'recording')", session_id)
capture.stop() capture.stop()
if pause_monitor:
session = self.db.get("SELECT channel_id FROM sessions WHERE id = ?", session_id)
if session and session["channel_id"]:
changed = self.db.run("UPDATE channels SET monitor_paused_at = ?, monitor_paused_session = ? WHERE id = ? AND monitor = 1",
now(), session_id, session["channel_id"]).rowcount
if changed:
log.info("fonte %s: monitor pausado (você parou a sessão %s)", session["channel_id"], session_id)
def clear_monitor_pause(self, channel_id: str) -> None:
"""Religa o monitor da fonte (PATCH monitor=true, gravar pelo link ou retomar uma sessão dela)."""
if self.db.run("UPDATE channels SET monitor_paused_at = NULL, monitor_paused_session = NULL WHERE id = ? AND monitor_paused_at IS NOT NULL",
channel_id).rowcount:
log.info("fonte %s: monitor religado", channel_id)
def capture_finished(self, session_id: int) -> None: def capture_finished(self, session_id: int) -> None:
with self.lock: with self.lock:
@@ -571,9 +597,19 @@ class Engine:
# ---------- monitor de canais # ---------- monitor de canais
def _monitor_loop(self) -> None: def _monitor_loop(self) -> None:
while not self.stop_event.is_set(): while not self.stop_event.is_set():
self.monitor_once()
self.stop_event.wait(self.settings.poll_s)
def monitor_once(self) -> list[int]:
"""Uma passada do monitor: checa cada fonte monitorada (e não pausada) sem sessão ativa e grava as que estão
ao vivo. Devolve os ids das sessões iniciadas (os testes chamam direto)."""
started: list[int] = []
for channel in self.db.all("SELECT * FROM channels WHERE monitor = 1"): for channel in self.db.all("SELECT * FROM channels WHERE monitor = 1"):
if self.stop_event.is_set(): if self.stop_event.is_set():
break break
if channel.get("monitor_paused_at"):
log.debug("fonte %s: monitor pausado (sessão %s parada à mão), pulando", channel["id"], channel.get("monitor_paused_session"))
continue
busy = self.db.get("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel["id"]) busy = self.db.get("SELECT id FROM sessions WHERE channel_id = ? AND status IN ('starting', 'recording')", channel["id"])
if busy: if busy:
continue continue
@@ -585,9 +621,10 @@ class Engine:
try: try:
session_id = self.start_session(channel["url"], channel["id"]) session_id = self.start_session(channel["url"], channel["id"])
self.db.run("UPDATE sessions SET title = ? WHERE id = ?", title[:200], session_id) self.db.run("UPDATE sessions SET title = ? WHERE id = ?", title[:200], session_id)
started.append(session_id)
except Exception as exc: # noqa: BLE001 except Exception as exc: # noqa: BLE001
log.warning("canal %s: não iniciou (%s)", channel["id"], exc) log.warning("canal %s: não iniciou (%s)", channel["id"], exc)
self.stop_event.wait(self.settings.poll_s) return started
def live_check(self, url: str) -> LiveCheck: def live_check(self, url: str) -> LiveCheck:
"""Streamlink --json, separando "offline" de "não deu para checar". Falha de checagem vai para o log com o """Streamlink --json, separando "offline" de "não deu para checar". Falha de checagem vai para o log com o
@@ -701,7 +738,9 @@ class Engine:
pcm = media.decode_pcm(self.settings.ffmpeg or "ffmpeg", [file]) pcm = media.decode_pcm(self.settings.ffmpeg or "ffmpeg", [file])
loudness = media.loudness_per_second(pcm) loudness = media.loudness_per_second(pcm)
try: try:
rel_words = self.voice.transcribe(media.to_wav(pcm), f"clipper-{segment['session_id']}-{segment['idx']}") owner = self.db.get("SELECT language FROM sessions WHERE id = ?", segment["session_id"])
rel_words = self.voice.transcribe(media.to_wav(pcm), f"clipper-{segment['session_id']}-{segment['idx']}",
language=(owner or {}).get("language") or None)
words = [Word(round(w.start + segment["start_s"], 3), round(w.end + segment["start_s"], 3), w.word) words = [Word(round(w.start + segment["start_s"], 3), round(w.end + segment["start_s"], 3), w.word)
for w in rel_words] for w in rel_words]
except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat except Exception as exc: # noqa: BLE001 - sem voz o corte segue pelo chat
@@ -1051,7 +1090,7 @@ class Engine:
self.db.run("UPDATE segments SET deleted = 1 WHERE session_id = ? AND idx = ?", seg["session_id"], seg["idx"]) self.db.run("UPDATE segments SET deleted = 1 WHERE session_id = ? AND idx = ?", seg["session_id"], seg["idx"])
def delete_session(self, session_id: int) -> None: def delete_session(self, session_id: int) -> None:
self.stop_session(session_id) self.stop_session(session_id, pause_monitor=False)
session = self.db.get("SELECT * FROM sessions WHERE id = ?", session_id) session = self.db.get("SELECT * FROM sessions WHERE id = ?", session_id)
if not session: if not session:
return return
+18
View File
@@ -0,0 +1,18 @@
"""Configuração comum dos testes do Clipador."""
import pytest
import app.ai_settings as ai_settings_module
import app.intel as intel_module
@pytest.fixture(autouse=True)
def _isolated_ai_settings(tmp_path_factory, monkeypatch):
# Configurações → IA do painel (data/ai real) não entram nos testes: cada teste começa com o padrão do doc.
monkeypatch.setattr(ai_settings_module, "DEFAULT_AI_DIR", tmp_path_factory.mktemp("ai-settings"))
@pytest.fixture(autouse=True)
def _no_real_game_seeds(tmp_path_factory, monkeypatch):
# As sementes de jogo do repositório (app/seeds/games, ex.: GTA VI) entrariam em todo banco de teste e mudariam
# a lista de jogos. Cada teste começa sem nenhuma; quem testa sementes passa a própria pasta.
monkeypatch.setattr(intel_module, "SEEDS_DIR", tmp_path_factory.mktemp("no-seeds"))
+313
View File
@@ -0,0 +1,313 @@
"""Gemini no juiz, IA reserva e modo chave de API (contrato em doc/ia.md). Nenhuma CLI de verdade roda aqui:
`subprocess.run` e os `find_*` do juiz são trocados por falsos."""
import json
import os
import subprocess
from pathlib import Path
import pytest
from app import judge as judge_module
from app.ai_settings import DEFAULT_SETTINGS, AiConfig, normalize_settings
from app.judge import (DEFAULT_MODELS, VERDICT_SCHEMA, Judge, JudgeError, extract_json_object, is_availability_error,
parse_gemini_output)
from tests.test_sources_and_api import KEY, auth, env # noqa: F401 - fixture reaproveitada
VERDICT = {"keep": True, "score": 8, "start_s": 100, "end_s": 170, "title": "Virada", "caption": "c",
"hashtags": ["lag"], "reason": "r"}
class ReversedCipher:
"""Cifrador falso: o "blob" é o JSON de trás para frente (garante que o cofre passa pelo cifrador)."""
def unprotect(self, data: bytes) -> bytes:
return data[::-1]
_STAMPS = iter(range(1_700_000_000, 1_800_000_000, 7))
def write_settings(folder: Path, data: dict) -> None:
folder.mkdir(parents=True, exist_ok=True)
path = folder / "settings.json"
path.write_text(json.dumps(data), encoding="utf-8")
# mtime sempre diferente do anterior (o sistema de arquivos pode ter resolução grossa)
stamp = next(_STAMPS) * 1_000_000_000
os.utime(path, ns=(stamp, stamp))
def write_vault(folder: Path, keys: dict) -> None:
folder.mkdir(parents=True, exist_ok=True)
(folder / "vault.bin").write_bytes(json.dumps(keys).encode("utf-8")[::-1])
def settings_with(**providers) -> dict:
data = json.loads(json.dumps(DEFAULT_SETTINGS))
for name, conf in providers.items():
data["providers"][name].update(conf)
return data
class FakeCli:
"""Faz o papel das três CLIs. `behavior[provider]` = "ok", "content" (resposta sem JSON) ou um texto de erro
(sai com código 1 e esse texto no stderr)."""
def __init__(self, behavior: dict[str, str]):
self.behavior = behavior
self.calls: list[dict] = []
def run(self, args, input=None, capture_output=True, timeout=None, cwd=None, creationflags=0, env=None):
provider = args[0]
self.calls.append({"provider": provider, "args": list(args), "env": dict(env or {}), "cwd": cwd,
"stdin": (input or b"").decode("utf-8"),
"files": sorted(p.name for p in Path(cwd).iterdir()) if cwd else []})
mode = self.behavior.get(provider, "ok")
if mode not in ("ok", "content"):
return subprocess.CompletedProcess(args, 1, b"", mode.encode("utf-8"))
answer = VERDICT if mode == "ok" else None
if provider == "codex":
out = Path(args[args.index("-o") + 1])
out.write_text(json.dumps(answer) if answer else "não sei", encoding="utf-8")
return subprocess.CompletedProcess(args, 0, b"", b"")
if provider == "claude":
envelope = {"is_error": False, "structured_output": answer, "result": "" if answer else "não sei"}
return subprocess.CompletedProcess(args, 0, json.dumps(envelope).encode(), b"")
text = f"Aqui está:\n```json\n{json.dumps(answer)}\n```" if answer else "Não consegui."
return subprocess.CompletedProcess(args, 0, json.dumps({"response": text, "stats": {}}).encode(), b"")
@pytest.fixture
def ai_dir(tmp_path):
return tmp_path / "ai"
@pytest.fixture
def make_judge(tmp_path, ai_dir, monkeypatch):
clock = {"t": 1_000_000.0}
def factory(behavior=None, provider="codex", model="", installed=("codex", "claude", "gemini")):
cli = FakeCli(behavior or {})
monkeypatch.setattr(judge_module.subprocess, "run", cli.run)
for name in ("codex", "claude", "gemini"):
monkeypatch.setattr(judge_module, f"find_{name}", (lambda n=name: [n] if n in installed else None))
ai = AiConfig(ai_dir, cipher=ReversedCipher(), environ={"PATH": "x", "ANTHROPIC_API_KEY": "global",
"GOOGLE_GENAI_USE_GCA": "true"})
judge = Judge(provider, model, tmp_path / "judge", ai=ai, clock=lambda: clock["t"])
judge.cli, judge.clock = cli, clock
return judge
return factory
# ---------------------------------------------------------------- classificador
@pytest.mark.parametrize("text", [
"Error: 429 Too Many Requests", "You've hit your usage limit", "Your credit balance is too low",
"API Error: 529 overloaded_error", "503 Service Unavailable", "Not logged in · Please run /login",
"invalid api key", "IneligibleTierError: UNSUPPORTED_CLIENT", "connect ECONNREFUSED 127.0.0.1",
"getaddrinfo ENOTFOUND api.openai.com", "network error", "a CLI passou de 240 s (tempo esgotado)",
"Codex CLI não encontrado", "RESOURCE_EXHAUSTED: quota exceeded", "401 Unauthorized", "status 403",
])
def test_availability_errors(text):
assert is_availability_error(text)
@pytest.mark.parametrize("text", ["", "o Codex não devolveu o JSON pedido", "resposta sem os campos ['title']",
"Expecting value: line 1 column 1", "schema validation failed"])
def test_content_errors_are_not_availability(text):
assert not is_availability_error(text)
# ---------------------------------------------------------------- settings.json e cofre
def test_settings_default_when_missing_or_invalid(ai_dir):
config = AiConfig(ai_dir, cipher=ReversedCipher())
assert config.settings() == DEFAULT_SETTINGS
ai_dir.mkdir(parents=True)
(ai_dir / "settings.json").write_text("{quebrado", encoding="utf-8")
assert AiConfig(ai_dir).settings() == DEFAULT_SETTINGS
assert DEFAULT_SETTINGS["providers"]["gemini"] == {"enabled": False, "authMode": "apiKey"}
def test_settings_normalized_field_by_field():
data = normalize_settings({"providers": {"gemini": {"enabled": True, "authMode": "senha"}, "gpt": {}},
"order": ["gemini", "gpt", "gemini"], "fallback": {"enabled": False, "cooldownMin": -3}})
assert data["providers"]["gemini"] == {"enabled": True, "authMode": "apiKey"} # modo inválido fica no padrão
assert data["order"] == ["gemini", "claude", "codex"] # desconhecido sai, faltantes vão para o fim
assert data["fallback"] == {"enabled": False, "cooldownMin": 15.0}
def test_settings_reread_when_mtime_changes(ai_dir):
config = AiConfig(ai_dir)
write_settings(ai_dir, settings_with(gemini={"enabled": True}))
assert config.settings()["providers"]["gemini"]["enabled"] is True
write_settings(ai_dir, settings_with(gemini={"enabled": False}, claude={"authMode": "apiKey"}))
assert config.settings()["providers"]["gemini"]["enabled"] is False
assert config.settings()["providers"]["claude"]["authMode"] == "apiKey"
def test_env_per_auth_mode(ai_dir):
environ = {"PATH": "x", "ANTHROPIC_API_KEY": "global", "CODEX_API_KEY": "global", "GEMINI_API_KEY": "global",
"GOOGLE_GENAI_USE_GCA": "true"}
config = AiConfig(ai_dir, cipher=ReversedCipher(), environ=environ)
write_vault(ai_dir, {"claude": "sk-ant-1", "gemini": "AIza-2", "outro": "x"})
# padrão: claude/codex em oauth (a variável sai), gemini em apiKey (a chave do cofre entra, GCA sai)
claude, codex, gemini = (config.provider_env(p) for p in ("claude", "codex", "gemini"))
assert "ANTHROPIC_API_KEY" not in claude and claude["PATH"] == "x"
assert "CODEX_API_KEY" not in codex
assert gemini["GEMINI_API_KEY"] == "AIza-2" and "GOOGLE_GENAI_USE_GCA" not in gemini
write_settings(ai_dir, settings_with(claude={"authMode": "apiKey"}, gemini={"authMode": "oauth"}))
assert config.provider_env("claude")["ANTHROPIC_API_KEY"] == "sk-ant-1"
gemini = config.provider_env("gemini")
assert gemini["GOOGLE_GENAI_USE_GCA"] == "true" and "GEMINI_API_KEY" not in gemini
assert environ["ANTHROPIC_API_KEY"] == "global" # o ambiente do processo não muda
assert config.api_keys() == {"claude": "sk-ant-1", "gemini": "AIza-2"}
def test_unreadable_vault_means_no_keys(ai_dir):
ai_dir.mkdir(parents=True)
(ai_dir / "vault.bin").write_bytes(b"\x00lixo")
config = AiConfig(ai_dir, cipher=ReversedCipher())
assert config.api_keys() == {} and config.vault_error
# ---------------------------------------------------------------- cadeia de reserva
def test_chain_skips_disabled_missing_cli_no_key_and_paused(make_judge, ai_dir):
judge = make_judge(provider="codex")
# padrão: gemini desligado → codex (escolhido) e depois claude
assert judge.fallback_chain() == ["codex", "claude"]
write_settings(ai_dir, settings_with(gemini={"enabled": True})) # ligado, mas sem chave no cofre
assert judge.fallback_chain() == ["codex", "claude"]
write_vault(ai_dir, {"gemini": "AIza"})
assert judge.fallback_chain() == ["codex", "claude", "gemini"]
judge.pause("claude", "429")
assert judge.fallback_chain() == ["codex", "gemini"]
judge.clock["t"] += 15 * 60 + 1 # a pausa vence
assert judge.fallback_chain() == ["codex", "claude", "gemini"]
write_settings(ai_dir, {**settings_with(gemini={"enabled": True}), "order": ["gemini", "codex", "claude"]})
assert judge.fallback_chain() == ["codex", "gemini", "claude"]
write_settings(ai_dir, {**settings_with(), "fallback": {"enabled": False, "cooldownMin": 15}})
assert judge.fallback_chain() == ["codex"]
write_settings(ai_dir, settings_with())
assert make_judge(provider="codex", installed=("claude",)).fallback_chain() == ["claude"] # codex sem CLI
def test_unavailable_switches_to_next_with_its_default_model_and_pauses(make_judge):
judge = make_judge({"codex": "Error: 429 Too Many Requests"}, provider="codex", model="gpt-caro")
verdict = judge.judge("prompt", 100, 170, lo=0, hi=300)
assert [c["provider"] for c in judge.cli.calls] == ["codex", "claude"]
assert verdict.model == f"claude:{DEFAULT_MODELS['claude']}" # quem de fato respondeu, com o modelo padrão dele
claude_args = judge.cli.calls[1]["args"]
assert claude_args[claude_args.index("--model") + 1] == "haiku"
pauses = judge.describe()["pauses"]
assert [p["provider"] for p in pauses] == ["codex"] and "429" in pauses[0]["reason"]
# próxima chamada já pula o codex em pausa
judge.cli.calls.clear()
judge.judge("prompt", 100, 170, lo=0, hi=300)
assert [c["provider"] for c in judge.cli.calls] == ["claude"]
def test_content_error_does_not_switch(make_judge):
judge = make_judge({"codex": "content"}, provider="codex")
with pytest.raises(JudgeError) as info:
judge.judge("prompt", 100, 170)
assert info.value.unavailable is False
assert [c["provider"] for c in judge.cli.calls] == ["codex"] and judge.pauses() == {}
def test_all_fail_raises_summary(make_judge):
judge = make_judge({"codex": "503 unavailable", "claude": "Not logged in"}, provider="codex")
with pytest.raises(JudgeError) as info:
judge.judge("prompt", 100, 170)
message = str(info.value)
assert "codex:" in message and "claude:haiku" in message and info.value.unavailable is True
assert set(judge.pauses()) == {"codex", "claude"}
def test_fallback_disabled_keeps_only_primary(make_judge, ai_dir):
write_settings(ai_dir, {**settings_with(), "fallback": {"enabled": False, "cooldownMin": 15}})
judge = make_judge({"codex": "429"}, provider="codex")
with pytest.raises(JudgeError):
judge.judge("prompt", 100, 170)
assert [c["provider"] for c in judge.cli.calls] == ["codex"] and judge.pauses() == {}
def test_primary_disabled_in_settings_is_skipped(make_judge, ai_dir):
write_settings(ai_dir, settings_with(codex={"enabled": False}))
judge = make_judge(provider="codex")
assert judge.judge("prompt", 100, 170).model == "claude:haiku"
assert judge.describe()["unavailableReason"] == "desligada em Configurações → IA"
def test_describe_format(make_judge, ai_dir):
judge = make_judge(provider="gemini", model="")
write_settings(ai_dir, settings_with(gemini={"enabled": True}))
write_vault(ai_dir, {"gemini": "AIza"})
judge.pause("codex", "usage limit")
data = judge.describe()
assert data["provider"] == "gemini" and data["model"] == "gemini-3.5-flash" and data["authMode"] == "apiKey"
assert data["fallback"] == {"enabled": True, "cooldownMin": 15.0, "chain": ["gemini", "claude"]}
assert data["pauses"][0]["provider"] == "codex" and data["pauses"][0]["until"].endswith("+00:00")
assert "gemini" in judge.models() and judge.models()["defaults"]["gemini"] == "gemini-3.5-flash"
# ---------------------------------------------------------------- Gemini
def test_gemini_call_args_images_and_env(make_judge, ai_dir, tmp_path):
write_settings(ai_dir, settings_with(gemini={"enabled": True}))
write_vault(ai_dir, {"gemini": "AIza-chave"})
frames = []
for i in range(2):
frame = tmp_path / "frames" / f"clip1-{i}.JPG"
frame.parent.mkdir(exist_ok=True)
frame.write_bytes(b"jpg")
frames.append(frame)
judge = make_judge(provider="gemini", model="gemini-2.5-pro")
verdict = judge.judge("PROMPT GRANDE", 100, 170, frames)
call = judge.cli.calls[0]
args = call["args"]
assert args[:2] == ["gemini", "-p"] and "@frame-01.jpg @frame-02.jpg" in args[2]
assert args[args.index("-o") + 1] == "json" and args[args.index("--approval-mode") + 1] == "plan"
assert "--skip-trust" in args and args[args.index("-m") + 1] == "gemini-2.5-pro"
assert "PROMPT GRANDE" in call["stdin"] and '"start_s"' in call["stdin"] and "PROMPT GRANDE" not in args[2]
assert call["files"] == ["frame-01.jpg", "frame-02.jpg"] # imagens copiadas para a pasta de trabalho
assert call["env"]["GEMINI_API_KEY"] == "AIza-chave" and "GOOGLE_GENAI_USE_GCA" not in call["env"]
assert verdict.model == "gemini:gemini-2.5-pro" and verdict.title == "Virada"
def test_extract_json_object_tolerates_fences_and_prose():
assert extract_json_object('```json\n{"a": 1}\n```') == {"a": 1}
assert extract_json_object('Claro! {"a": {"b": [1, 2]}} espero ter ajudado') == {"a": {"b": [1, 2]}}
assert extract_json_object("o conjunto {x} e depois {\"ok\": true}") == {"ok": True}
assert extract_json_object("sem json") is None and extract_json_object("") is None
def test_parse_gemini_output():
assert parse_gemini_output(json.dumps({"response": '```json\n{"keep": true}\n```', "stats": {}})) == {"keep": True}
with pytest.raises(JudgeError) as info:
parse_gemini_output(json.dumps({"response": "não deu"}))
assert info.value.unavailable is False
with pytest.raises(JudgeError) as info:
parse_gemini_output(json.dumps({"error": {"type": "Error", "message": "429 RESOURCE_EXHAUSTED quota"}}))
assert info.value.unavailable is None and is_availability_error(str(info.value))
assert set(VERDICT) == set(VERDICT_SCHEMA["required"])
def test_find_gemini_runs_bundle_with_node_on_windows(tmp_path, monkeypatch):
npm = tmp_path / "npm"
bundle = npm / "node_modules" / "@google" / "gemini-cli" / "bundle" / "gemini.js"
bundle.parent.mkdir(parents=True)
bundle.write_text("//", encoding="utf-8")
monkeypatch.delenv("GEMINI_BIN", raising=False)
monkeypatch.setattr(judge_module.sys, "platform", "win32")
which = {"gemini.cmd": str(npm / "gemini.cmd"), "node": "C:/node/node.exe"}
monkeypatch.setattr(judge_module.shutil, "which", lambda name: which.get(name))
assert judge_module.find_gemini() == ["C:/node/node.exe", str(bundle)]
# ---------------------------------------------------------------- API
def test_api_accepts_gemini(env): # noqa: F811
client, engine = env
r = client.put("/v1/judge", json={"provider": "gemini", "model": "", "minScore": 6}, headers=auth())
assert r.status_code == 200
body = r.json()
assert body["provider"] == "gemini" and body["model"] == "gemini-3.5-flash" and "gemini" in body["models"]
assert "chain" in body["fallback"] and isinstance(body["pauses"], list)
+187
View File
@@ -0,0 +1,187 @@
"""Perfis de jogo bilíngues (doc/clipador/JOGOS.md): inglês para a IA, português para ler, missões, gatilhos de fim,
outros nomes, cadastro pelo painel e sementes."""
import json
from app.intel import clean_profile
from app.judge import JudgeError
from tests.test_sources_and_api import FakeJudge, auth, env, seed_session # noqa: F401 - fixture reaproveitada
EN = {
"name": "Grand Theft Auto VI", "aliases": ["GTA 6", "GTA VI"], "summary": "Open-world crime game in Leonida.",
"genre": "Action", "mechanics": ["heists"], "clip_worthy": ["police chase ends in a crash"], "avoid": ["menus"],
"jargon": ["wanted level"], "news": ["Released Nov 2026"], "hashtags": ["#GTA6"], "sources": ["https://example.com"],
"missions": [{"name": "Hometown", "chapter": "Prologue", "summary": "Lucia and Jason meet.",
"completion_triggers": ["MISSION PASSED banner"]}],
"end_triggers": ["MISSION PASSED", "WASTED"],
}
def to_pt(profile: dict) -> dict:
"""Tradução falsa: marca os textos traduzíveis com [pt] e mantém o resto, como o TRANSLATE_SYSTEM pede."""
out = json.loads(json.dumps(profile))
out["summary"] = "[pt] " + out["summary"]
out["clip_worthy"] = ["[pt] " + x for x in out["clip_worthy"]]
for m in out["missions"]:
m["summary"] = "[pt] " + m["summary"]
return out
class BilingualJudge(FakeJudge):
def __init__(self, fail_translate=False):
super().__init__()
self.fail_translate = fail_translate
self.translations: list[str] = []
def research_game(self, name, live_title="", notes=None):
return {**EN, "name": name}
def translate_game(self, profile, target):
self.translations.append(target)
if self.fail_translate:
raise JudgeError("cota acabou")
if target == "pt-BR":
return to_pt(profile)
back = json.loads(json.dumps(profile))
back["summary"] = "[en] " + back["summary"]
return back
def refine_game(self, name, profile, instruction, search=True, section="", history=None):
return {**profile, "end_triggers": [*profile["end_triggers"], "Reward screen"], "reply": "Acrescentei a tela de recompensa."}
def add(engine, name="Grand Theft Auto VI"):
engine.db.run("INSERT INTO games (id, name, status) VALUES (?, ?, 'pending')",
name.lower().replace(" ", "-"), name)
return name.lower().replace(" ", "-")
def test_research_stores_english_for_ai_and_portuguese_for_reading(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge()
gid = add(engine)
engine.intel.research(gid)
game = client.get("/v1/games", headers=auth()).json()["games"][0]
assert game["status"] == "ready" and game["aiLanguage"] == "en-US" and game["translatedAt"]
assert game["profileAi"]["summary"] == EN["summary"]
assert game["profile"]["summary"].startswith("[pt] ")
# Nome oficial da missão e hashtags não mudam na tradução.
assert game["profile"]["missions"][0]["name"] == "Hometown" and game["profile"]["hashtags"] == ["#GTA6"]
assert game["aliases"] == ["gta-6", "gta-vi"]
# A IA lê o inglês.
assert engine.intel.profile("Grand Theft Auto VI")["summary"] == EN["summary"]
def test_failed_translation_keeps_english_in_both_and_explains(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge(fail_translate=True)
gid = add(engine)
engine.intel.research(gid)
game = client.get("/v1/games", headers=auth()).json()["games"][0]
assert game["status"] == "ready" and "tradução falhou" in game["error"]
assert game["profile"]["summary"] == EN["summary"] and game["translatedAt"] is None
def test_manual_save_in_portuguese_translates_to_english(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge()
gid = add(engine)
engine.intel.research(gid)
pt = to_pt(EN)
pt["summary"] = "Jogo de crime em Leonida, editado por mim."
r = client.put(f"/v1/games/{gid}", json=pt, headers=auth())
assert r.status_code == 200
game = r.json()["games"][0]
assert game["profile"]["summary"] == "Jogo de crime em Leonida, editado por mim."
assert game["profileAi"]["summary"] == "[en] Jogo de crime em Leonida, editado por mim." and game["editedAt"]
assert engine.judge.translations[-1] == "en-US"
# Editar a versão da IA direto (lang=en) traduz para português.
r = client.put(f"/v1/games/{gid}?lang=en", json=EN, headers=auth())
assert r.json()["games"][0]["profileAi"]["summary"] == EN["summary"]
assert engine.judge.translations[-1] == "pt-BR"
def test_refine_applies_on_english_and_replies_in_portuguese(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge()
gid = add(engine)
engine.intel.research(gid)
r = client.post(f"/v1/games/{gid}/refine", json={"instruction": "acrescente a tela de recompensa", "section": "end_triggers"},
headers=auth())
assert r.status_code == 200 and r.json()["reply"] == "Acrescentei a tela de recompensa."
game = r.json()["games"][0]
assert "Reward screen" in game["profileAi"]["end_triggers"] and "Reward screen" in game["profile"]["end_triggers"]
def test_context_uses_english_profile_with_missions_and_end_triggers(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge()
engine.intel.research(add(engine))
sid = seed_session(engine)
# Categoria por outro nome ("GTA 6") cai no mesmo perfil.
engine.db.run("UPDATE sessions SET game = 'GTA 6' WHERE id = ?", sid)
context = engine.intel.context(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid))
assert EN["summary"] in context and "MISSION PASSED; WASTED" in context
assert "Hometown (fim: MISSION PASSED banner)" in context and "termine o corte logo depois do gatilho" in context
def test_mission_list_in_prompt_is_capped():
from app.judge import mission_lines
profile = clean_profile({"missions": [{"name": f"Mission number {i}", "completion_triggers": ["MISSION PASSED"]}
for i in range(110)]})
lines = mission_lines(profile)
assert len(profile["missions"]) == 110
missions = next(line for line in lines if line.startswith("Missões"))
assert "…e mais" in missions and len(missions) < 1700
def test_add_game_conflicts_by_alias_and_delete(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge()
engine.intel.research(add(engine))
r = client.post("/v1/games", json={"name": "GTA 6"}, headers=auth())
assert r.status_code == 409 and "já está na lista" in r.json()["error"]
r = client.post("/v1/games", json={"name": "Hollow Knight: Silksong", "notes": "foco em chefes"}, headers=auth())
assert r.status_code == 201 and r.json()["id"] == "hollow-knight-silksong"
new = next(g for g in r.json()["games"] if g["id"] == "hollow-knight-silksong")
assert new["notes"][0]["text"] == "foco em chefes"
r = client.delete("/v1/games/hollow-knight-silksong", headers=auth())
assert r.status_code == 200 and all(g["id"] != "hollow-knight-silksong" for g in r.json()["games"])
assert client.delete("/v1/games/nao-existe", headers=auth()).status_code == 404
def test_translate_route_makes_ai_version_for_old_games(env): # noqa: F811
client, engine = env
engine.judge = BilingualJudge()
engine.db.run("INSERT INTO games (id, name, status, profile_json) VALUES ('rob-run', 'ROB RUN', 'ready', ?)",
json.dumps(clean_profile({"name": "ROB RUN", "summary": "Jogo de assalto."})))
assert client.get("/v1/games", headers=auth()).json()["games"][0]["profileAi"] is None
r = client.post("/v1/games/rob-run/translate", headers=auth())
assert r.status_code == 200 and r.json()["games"][0]["profileAi"]["summary"] == "[en] Jogo de assalto."
def test_seeds_import_once_and_never_overwrite(env, tmp_path): # noqa: F811
_, engine = env
folder = tmp_path / "seeds"
folder.mkdir()
(folder / "game.json").write_text(json.dumps({
"name": "Seed Game", "aliases": ["SG"], "researchedAt": "2026-11-18T00:00:00+00:00", "sources": ["https://a"],
"profileAi": {"summary": "English summary", "missions": [{"name": "M1"}]},
"profile": {"summary": "Resumo em português", "missions": [{"name": "M1"}]},
}), encoding="utf-8")
assert engine.intel.import_seeds(folder) == ["seed-game"]
row = engine.db.get("SELECT * FROM games WHERE id = 'seed-game'")
assert row["status"] == "ready" and row["model"] == "seed"
assert json.loads(row["profile_ai_json"])["aliases"] == ["SG"] and json.loads(row["profile_json"])["sources"] == ["https://a"]
assert engine.intel.profile("SG")["summary"] == "English summary"
engine.db.run("UPDATE games SET profile_json = '{\"summary\": \"editado\"}' WHERE id = 'seed-game'")
assert engine.intel.import_seeds(folder) == []
assert json.loads(engine.db.get("SELECT profile_json FROM games WHERE id = 'seed-game'")["profile_json"])["summary"] == "editado"
def test_category_by_alias_does_not_create_duplicate_game(env): # noqa: F811
_, engine = env
engine.judge = BilingualJudge()
engine.intel.research(add(engine))
sid = seed_session(engine)
engine.intel.set_game(sid, "GTA VI", "platform")
assert [r["id"] for r in engine.db.all("SELECT id FROM games")] == ["grand-theft-auto-vi"]
@@ -0,0 +1,170 @@
"""Parar à mão pausa o monitor da fonte (reclamação de 18/11/2026: 60 s depois de "Parar" o monitor abria uma sessão
nova, porque a live continuava no ar) e idioma por fonte/sessão (transcrição e textos da IA em outro idioma)."""
from dataclasses import replace
import pytest
import app.worker as worker_module
from app.judge import output_language_note
from .test_sources_and_api import auth, env # noqa: F401 - fixture reaproveitada
URL = "https://www.twitch.tv/alanzoka"
CHANNEL = "twitch-alanzoka"
class FakeCapture:
"""Captura falsa: `stop` avisa o motor como a real faz ao terminar (sai de `captures`, senão não dá para retomar)."""
def __init__(self, eng, session_id, source, workdir, start_idx=0):
self.eng, self.session_id = eng, session_id
self.chat = None
def start(self):
pass
def stop(self):
self.eng.capture_finished(self.session_id)
@pytest.fixture
def ready(env, monkeypatch): # noqa: F811
"""Serviço com ferramentas "achadas", captura falsa e a live sempre no ar (sem Streamlink de verdade)."""
client, engine = env
monkeypatch.setattr(engine, "settings", replace(engine.settings, streamlink="streamlink", ffmpeg="ffmpeg"))
monkeypatch.setattr(worker_module, "Capture", FakeCapture)
monkeypatch.setattr(engine, "_fill_title", lambda *_a, **_k: None)
# A pasta de dados do teste fica fora do repositório: o caminho relativo da sessão não importa aqui.
monkeypatch.setattr(worker_module, "rel", lambda path: path.as_posix())
engine.check_live = lambda url: (True, "live no ar")
return client, engine
def channel(client):
return next(c for c in client.get("/v1/channels", headers=auth()).json()["channels"] if c["id"] == CHANNEL)
def test_stop_by_hand_pauses_monitor_until_relit(ready):
client, engine = ready
assert client.post("/v1/channels", json={"url": URL}, headers=auth()).status_code == 201
started = engine.monitor_once()
assert len(started) == 1
sid = started[0]
assert channel(client)["monitorPausedAt"] is None
# Parar sem corpo (painel antigo) = pausa o monitor da fonte.
assert client.post(f"/v1/sessions/{sid}/stop", headers=auth()).json() == {"ok": True}
c = channel(client)
assert c["monitor"] is True and c["monitorPausedAt"] and c["monitorPausedBySession"] == sid
assert engine.db.get("SELECT status FROM sessions WHERE id = ?", sid)["status"] == "stopped"
# A live continua no ar, mas o monitor NÃO abre sessão nova.
assert engine.monitor_once() == []
assert engine.db.get("SELECT COUNT(*) AS n FROM sessions")["n"] == 1
# "Religar" = PATCH monitor=true limpa a pausa; a próxima passada grava de novo.
r = client.patch(f"/v1/channels/{CHANNEL}", json={"monitor": True}, headers=auth())
assert r.json()["monitorPausedAt"] is None and r.json()["monitorPausedBySession"] is None
assert len(engine.monitor_once()) == 1
def test_stop_without_pause_keeps_monitor(ready):
client, engine = ready
client.post("/v1/channels", json={"url": URL}, headers=auth())
sid = engine.monitor_once()[0]
client.post(f"/v1/sessions/{sid}/stop", json={"pauseMonitor": False}, headers=auth())
assert channel(client)["monitorPausedAt"] is None
assert len(engine.monitor_once()) == 1 # a live segue no ar: grava de novo (você pediu assim)
def test_recording_by_link_or_resuming_relights_monitor(ready):
client, engine = ready
client.post("/v1/channels", json={"url": URL}, headers=auth())
sid = engine.monitor_once()[0]
client.post(f"/v1/sessions/{sid}/stop", headers=auth())
assert channel(client)["monitorPausedAt"]
# Gravar pelo link à mão: você ligou de propósito → a pausa some.
r = client.post("/v1/sessions", json={"url": URL}, headers=auth())
assert r.status_code == 201 and r.json()["id"] != sid
assert channel(client)["monitorPausedAt"] is None
# Parar de novo e retomar pelo painel também religa.
client.post(f"/v1/sessions/{r.json()['id']}/stop", headers=auth())
assert channel(client)["monitorPausedAt"]
assert client.post(f"/v1/sessions/{r.json()['id']}/resume", headers=auth()).status_code == 200
assert channel(client)["monitorPausedAt"] is None
def test_deleting_a_session_does_not_pause(ready):
client, engine = ready
client.post("/v1/channels", json={"url": URL}, headers=auth())
sid = engine.monitor_once()[0]
assert client.delete(f"/v1/sessions/{sid}", headers=auth()).status_code == 204
assert channel(client)["monitorPausedAt"] is None
def test_unmonitored_channel_is_not_paused(ready):
client, engine = ready
client.post("/v1/channels", json={"url": URL, "monitor": False}, headers=auth())
sid = client.post("/v1/sessions", json={"url": URL}, headers=auth()).json()["id"]
client.post(f"/v1/sessions/{sid}/stop", headers=auth())
assert channel(client)["monitorPausedAt"] is None # nada a pausar: o monitor já estava desligado
# ---------- idioma
def test_language_on_channel_and_session(ready):
client, engine = ready
default = engine.settings.language
r = client.post("/v1/channels", json={"url": URL, "language": "en-US"}, headers=auth())
assert r.status_code == 201 and r.json()["language"] == "en-US"
assert client.post("/v1/channels", json={"url": "https://kick.com/gaules", "language": "xx"}, headers=auth()).status_code == 400
r2 = client.post("/v1/channels", json={"url": "https://kick.com/gaules"}, headers=auth())
assert r2.json()["language"] == default # sem idioma = padrão do serviço, já resolvido na visão
# A sessão herda o idioma da fonte; `language` explícito vence; VOD solto fica no padrão.
s = client.post("/v1/sessions", json={"url": URL}, headers=auth()).json()
assert s["language"] == "en-US"
assert engine.db.get("SELECT language FROM sessions WHERE id = ?", s["id"])["language"] == "en-US"
s2 = client.post("/v1/sessions", json={"url": "https://kick.com/gaules", "language": "es-419"}, headers=auth()).json()
assert s2["language"] == "es-419"
assert client.post("/v1/sessions", json={"url": URL, "language": "klingon"}, headers=auth()).status_code == 400
# PATCH troca ('' volta ao padrão) e não mexe quando ausente.
assert client.patch(f"/v1/channels/{CHANNEL}", json={"displayName": "Alan"}, headers=auth()).json()["language"] == "en-US"
assert client.patch(f"/v1/channels/{CHANNEL}", json={"language": ""}, headers=auth()).json()["language"] == default
assert client.get("/v1/status", headers=auth()).json()["settings"]["language"] == default
def test_language_note_reaches_the_ai_context(ready):
client, engine = ready
assert output_language_note("pt-BR") == "" and output_language_note("") == "" and output_language_note(None) == ""
assert "English (US)" in output_language_note("en-US")
client.post("/v1/channels", json={"url": URL, "language": "en-US"}, headers=auth())
sid = client.post("/v1/sessions", json={"url": URL}, headers=auth()).json()["id"]
gringa = engine.db.get("SELECT * FROM sessions WHERE id = ?", sid)
assert "Idioma de saída: English (US)" in engine.intel.context(gringa)
engine.db.run("UPDATE sessions SET language = '' WHERE id = ?", sid)
assert "Idioma de saída" not in engine.intel.context(engine.db.get("SELECT * FROM sessions WHERE id = ?", sid))
def test_transcription_uses_session_language(ready, monkeypatch):
_client, engine = ready
seen = {}
class FakeVoice:
configured = True
def transcribe(self, wav, key, language=None):
seen["language"] = language
return []
monkeypatch.setattr(engine, "voice", FakeVoice())
monkeypatch.setattr(worker_module.media, "decode_pcm", lambda *_a, **_k: b"")
monkeypatch.setattr(worker_module.media, "loudness_per_second", lambda _pcm: [])
monkeypatch.setattr(worker_module.media, "to_wav", lambda _pcm: b"")
cur = engine.db.run("INSERT INTO sessions (platform, kind, url, status, dir, started_at, language) VALUES"
" ('twitch', 'live', ?, 'processing', '', '2026-11-18T00:00:00+00:00', 'en-US')", URL)
sid = cur.lastrowid
engine.db.run("INSERT INTO segments (session_id, idx, file, start_s, end_s, wall_end) VALUES (?, 0, 'x/seg.ts', 0, 30, 0)", sid)
engine.analyze_segment(engine.db.get("SELECT * FROM segments WHERE session_id = ?", sid))
assert seen["language"] == "en-US"
+79
View File
@@ -0,0 +1,79 @@
# Expressões, movimento e fala do estilo Cartoon
Nada aqui é animação pronta: o personagem tem um **rig** (rosto e corpo por parâmetros) e uma **linha do
tempo** de ações que se combinam. Expressões e poses com nome são só atalhos — ajuste qualquer valor por cima
ou crie combinações novas. Código: `cartoon/src/rig.ts`, `motion.ts`, `lipsync.ts`, `CharacterFigure.tsx`.
## Rosto (FaceParams)
| Parâmetro | Faixa | Efeito |
|---|---|---|
| `browL` / `browR` `{ y, tilt }` | y −10…6 px · tilt −25…25° | y negativo sobe; tilt + = ponta de dentro sobe (triste), − = desce (bravo) |
| `eyeL` / `eyeR` | 0…1,35 | 0 fechado · 1 normal · 1,35 arregalado (fechado + sorriso = olho de riso em arco) |
| `pupil` | 0,4…1,3 | pupila pequena = pavor |
| `gazeX` / `gazeY` | −1…1 | para onde olha |
| `mouthOpen` | 0…1 | abertura |
| `smile` | −1…1 | cantos para baixo (triste/bravo) ou para cima (feliz) |
| `mouthWidth` | 0,5…1,4 | estreita (O de susto) ou larga |
| `mouthRound` | 0…1 | bico de "o/u" (a fala usa) |
| `teeth` | sim/não | dentes à mostra |
| `blush`, `sweat`, `tears`, `anger` | 0…1 / sim/não | rubor, gota de suor, lágrimas escorrendo, veia de raiva |
Atalhos (`expression`): neutral, smile, happy, laugh, proud, sad, cry, worried, angry, furious, surprised,
scared, shocked, suspicious, smirk, confused, disgusted, sleepy, determined, embarrassed.
Ajuste fino no ator: `"face": { "smile": 0.3, "browL": { "y": -6 } }` (aceita `brows` e `eyes` para os dois
lados). Expressão nova = combinação de parâmetros; não precisa de desenho novo.
## Corpo (BodyParams)
Braços e pernas em dois segmentos: `raise` (abre a partir do corpo: 0 baixo, 90 horizontal, 180 para cima) e
`bend` (dobra o cotovelo/joelho para dentro). Mais `lean` (tronco), `headTilt`, `headTurn` (−1…1, finge 3/4),
`headNod` (−1 olha para cima … 1 para baixo) e `crouch` (0 em pé … 1 sentado).
Atalhos (`pose`): stand, point, wave, hold, arms_up, celebrate, shrug, think, hands_on_hips, cross_arms,
facepalm, cover_mouth, defend, reach, sit, kneel, lean_in. Ajuste: `"body": { "armR": { "raise": 60 } }`.
## Linha do tempo (`timeline` do ator)
Cada ação começa em `at` (segundos), `atP` (fração do trecho) ou **`cue`** (a palavra da narração: começa quando
a voz diz essa palavra — o jeito preferido). `dur` muda a duração.
| Ação | Efeito | Campos |
|---|---|---|
| `express` | troca de expressão (suave, fica) | `expression` e/ou `face` |
| `pose` | troca de pose (com leve passada do ponto) | `pose` e/ou `body` |
| `walk` / `run` | anda/corre até `to` (x), virando para o lado | `to` |
| `enter` / `exit` | entra de fora do quadro / sai | `to` |
| `jump` | preparação, salto com esticada, aterrissagem | `height` |
| `nod` / `shake_head` | sim / não com a cabeça | `times` |
| `tremble` · `bounce` | tremer · quicar de alegria | `times` |
| `fall` | cai de lado (cara de choque) | `dir` |
| `sit` / `stand_up` | senta / levanta | — |
| `turn` | vira (espelha passando pelo perfil) | — |
| `look` | olhar e cabeça para um lado | `dir` left/right/up/down |
| `wave` | acena | `times` |
| `emote` | balão sobre a cabeça | `text` "!", "?", "…" |
| `talk` | fala: boca pelas letras e volume | `cue` + `cueEnd` (palavras) ou `text` + `dur` |
Sempre há "vida": piscar em intervalos variados, respirar e balanço leve de cabeça.
## Fala com expressão
`talk` usa os tempos de cada palavra (transcrição do áudio do trecho) e o volume do áudio quadro a quadro
(`audioEnv`, gerado pelo painel). A boca segue as letras — "a" abre, "e/i" esticam, "o/u" arredondam,
"m/b/p" fecham, "f/v" mostram os dentes —, fecha nas pausas e abre mais nas sílabas fortes. **A expressão
continua**: os cantos da boca, as sobrancelhas e os olhos são dela (bravo falando segue bravo).
Para um personagem dizer uma fala da narração: `{ "do": "talk", "cue": "primeira", "cueEnd": "ultima" }`.
## Como o plano automático usa isso (panel/src/lib/montage-cartoon.ts → `timelineFor`)
- Emoção na palavra: "medo" → `express scared` com `cue: "medo"` (o personagem começa neutro).
- Verbos viram ações: andou/correu/pulou/caiu/sentou/levantou/negou/concordou/tremeu/riu/chorou/olhou/virou/
pensou/acenou/apontou/cruzou os braços/comemorou; "de repente" → balão "!"; "por que/será" → "?".
- Fala entre aspas ou depois de travessão → `talk` do personagem de `cue` (1ª palavra) a `cueEnd` (última).
## Boas práticas
- Uma mudança de expressão por frase basta; muitas trocas parecem tique.
- Ação no verbo, emoção na palavra da emoção: o público vê acontecer quando ouve.
- Movimento grande (correr, cair) pede câmera parada; parado falando pede `push` lento.
+14 -2
View File
@@ -46,6 +46,12 @@ cria (pela descrição), ajusta e apaga. O elenco de cada história fica em `sto
| `top.style` | `shirt`, `jacket`, `hoodie`, `dress`, `uniform` (`accent` = faixa/gola) | | `top.style` | `shirt`, `jacket`, `hoodie`, `dress`, `uniform` (`accent` = faixa/gola) |
| `bottom.style` | `pants`, `shorts`, `skirt` | | `bottom.style` | `pants`, `shorts`, `skirt` |
| cores | sempre `#rrggbb` | | cores | sempre `#rrggbb` |
| `head` (opcional) | `round`, `oval`, `square`, `wide` |
| `nose` (opcional) | `button`, `curve` (de perfil, tipo C), `round`, `long`, `wide` |
| `lids` (opcional) | 0 a 0,6 — pálpebra de cima de base: olhar caído, experiente (o que mais dá "cara de ilustração") |
| `wrinkles` (opcional) | 0 a 1 — testa, canto dos olhos e bigode chinês |
| `belly` (opcional) | barriga saliente |
| `accessories` (opcional) | `towel`, `whistle`, `tie`, `vest`, `helmet`, `watch`, `badge`, `apron`, `scarf`, `headset`, `chain` (+ `accessoryColor`) |
`kind: "3d"` reserva o personagem para a Godot (pessoa articulada de `godot/kits/`, parâmetros em `godot`); `kind: "3d"` reserva o personagem para a Godot (pessoa articulada de `godot/kits/`, parâmetros em `godot`);
o Cartoon ignora esses. o Cartoon ignora esses.
@@ -54,13 +60,19 @@ o Cartoon ignora esses.
No spec do trecho (`cartoon/src/spec.ts`), um ator `person` com `character` (nome, legenda, look) e: No spec do trecho (`cartoon/src/spec.ts`), um ator `person` com `character` (nome, legenda, look) e:
- `expression`: `neutral`, `happy`, `sad`, `worried`, `angry`, `surprised`, `scared` - `expression` e `pose`: atalhos do rig (20 expressões, 17 poses) com ajuste fino `face`/`body`, e
- `pose`: `stand`, `point`, `wave`, `hold`, `arms_up`, `shrug`, `think` `timeline` com movimento e fala — tudo em `doc/cartoon/animacao.md`.
- `item` (com `hold`/`point`): ícone na mão — `phone`, `fuel`, `battery`, `money`, `bulb`, `clock`, … - `item` (com `hold`/`point`): ícone na mão — `phone`, `fuel`, `battery`, `money`, `bulb`, `clock`, …
- `flip`: olha para a esquerda. - `flip`: olha para a esquerda.
## Como criar um bom personagem ## Como criar um bom personagem
Nível de acabamento de ilustração (referência estudada em 17/11/2026: ilustrações de série no Instagram):
pálpebra caída (`lids` 0,25–0,35) + nariz + rugas para os mais velhos, uma marca de profissão nos acessórios
(apito do técnico, capacete e colete do operário, avental da merendeira), corpo com formato (barriga, ombro) e,
quando ele é o centro da cena, enquadramento `medium` ou `close`. A cena inteira ganha textura de papel (`grain`).
A descrição em texto já preenche tudo isso por regras (idade, profissão, "barrigudo", "narigudo", "cansado"…).
- Uma silhueta reconhecível de longe: **uma** marca forte (careca + barba grisalha, coque branco, boné vermelho). - Uma silhueta reconhecível de longe: **uma** marca forte (careca + barba grisalha, coque branco, boné vermelho).
- Roupa de cor chapada que contraste com a paleta da série (sépia pede verde/azul; noite pede amarelo/roxo). - Roupa de cor chapada que contraste com a paleta da série (sépia pede verde/azul; noite pede amarelo/roxo).
- `caption` curta, com função e idade ("Engenheiro de minas · 58 anos"): aparece na 1ª cena. - `caption` curta, com função e idade ("Engenheiro de minas · 58 anos"): aparece na 1ª cena.
+75
View File
@@ -0,0 +1,75 @@
# Clipador — perfis de jogo bilíngues, missões e gatilhos (18/11/2026)
## Pedido do dono
- Perfil do jogo em **português para ler** e em **inglês para a IA** (é o que vai nos prompts).
- Cadastrar **jogo novo** pelo painel (antes só nascia quando uma live trazia a categoria).
- **Missões** do jogo (quando já estão publicadas na internet) e **gatilhos de fim de missão**.
- Jogos em **lista**; clicar abre um **modal** (o cartão grande ocupava a tela).
- **GTA 6 completo**.
## Contrato (serviço `clipper/` ↔ painel)
### Perfil (mesmo formato nos dois idiomas)
```jsonc
{
"name": "Grand Theft Auto VI",
"aliases": ["GTA 6", "GTA VI", "GTA6"], // outros nomes: a categoria da Twitch e o que a IA vê na tela caem no mesmo jogo
"summary": "…", "genre": "…",
"mechanics": [], "clip_worthy": [], "avoid": [], "jargon": [], "news": [], "hashtags": [], "sources": [],
"missions": [ // [] quando ainda não há lista pública confiável
{ "name": "…", "chapter": "…", "summary": "…", "completion_triggers": ["…"] }
],
"end_triggers": ["…"] // sinais gerais de fim de missão/objetivo (banner, tela de resultado, fala)
}
```
### `GET /v1/games` — cada jogo
| Campo | O que é |
|---|---|
| `profile` | Perfil em **português** (o que o painel mostra). Jogos antigos: o perfil que já existia. |
| `profileAi` | Perfil em **inglês** (o que vai para a IA). `null` = ainda não traduzido (a IA usa `profile`). |
| `aiLanguage` | `"en-US"` |
| `translatedAt` | Quando a versão da IA foi gerada a partir da outra (ou vice-versa). |
| `aliases` | Atalho de `profileAi.aliases ∪ profile.aliases`. |
| demais | `id, name, status (pending/ready/error), error, model, researchedAt, editedAt, notes` (como antes) |
### Rotas
| Rota | O que faz |
|---|---|
| `POST /v1/games` `{name, notes?}` | Cadastra jogo (status `pending`) e pesquisa em segundo plano. 409 se já existe (inclusive por alias). |
| `POST /v1/games/{id}/research` | Pesquisa na web **em inglês** (missões e gatilhos inclusos) e traduz para português. |
| `PUT /v1/games/{id}?lang=pt\|en` | Grava a edição à mão no idioma `lang` (padrão `pt`) e traduz para o outro. Sem IA ligada: grava e marca a outra versão como desatualizada. |
| `POST /v1/games/{id}/refine` | Pedido à IA (em português): atualiza a versão em inglês e traduz para português. Resposta `reply` em português. |
| `POST /v1/games/{id}/translate` | Gera a versão em inglês a partir da portuguesa (jogos antigos). |
| `DELETE /v1/games/{id}` | Apaga o jogo (sessões não mudam; o perfil é pesquisado de novo se o jogo voltar). |
Detalhes da implementação (serviço):
- `POST /v1/games` responde `{games, id}` (201); `DELETE` responde a lista. `PUT ?lang=` aceita `pt` (padrão) ou `en`.
- `refine` aceita também as seções `missions`, `end_triggers` e `aliases`.
- Tradução que falha (ou IA desligada): a versão traduzida fica como estava (na pesquisa, as duas em inglês) e
`error` explica; `translatedAt` só muda quando a tradução deu certo. A tradução nunca mexe em nome, hashtags,
fontes e outros nomes, e é recusada se perder missões.
- Limites: até 120 missões, 8 gatilhos por missão (200 caracteres), 10 outros nomes, 12 `end_triggers`.
### Sementes
`clipper/app/seeds/games/*.json` (formato: `{name, aliases, researchedAt, sources, profileAi, profile}`) é
importado na subida do serviço **só se o jogo ainda não existe** (nunca sobrescreve edição). O GTA VI vem assim.
### Prompts
- O contexto da IA (`game_context`) usa `profileAi` (fallback `profile`), inclui `end_triggers` e as missões
(nome + gatilhos, limitado) e diz ao editor: corte de missão termina logo depois do gatilho de fim.
- Busca por nome casa `id` **ou** alias (categoria "Grand Theft Auto VI", tela "GTA 6" → mesmo perfil).
## Painel
- `/clipper/games`: tabela (nome, gênero, estado, missões, última pesquisa/edição) + "Adicionar jogo" (diálogo).
- Clique abre o **modal do jogo**: abas Visão geral · Rende corte · Missões · Gatilhos de fim · Termos e hashtags ·
Fontes · Pedidos à IA; alternância **Português (você lê) / English (vai para a IA)**; ações Pesquisar de novo, Editar, Pedir à
IA, Apagar.
+64
View File
@@ -0,0 +1,64 @@
# Clipador — reorganização da interface (18/11/2026)
## Por que
A página `/clipper` cresceu por acréscimo: um resumo com 4 cartões, a barra da live, 5 abas, e dentro
delas cartões gigantes (um corte ocupa meia tela; uma sessão, uma tela inteira). Os cliques ficaram
confusos (ação primária e secundária no mesmo peso), a informação do corte aprovado se perde, e não há
lugar para o que vem a seguir: canais em outros idiomas (público gringo) ao lado dos canais em português.
## O que muda
### Navegação: subpáginas, não abas
| Rota | O que é | Conteúdo |
|---|---|---|
| `/clipper` | **Cortes** | Lista (uma linha por corte), filtros por etapa / fonte / sessão / idioma, ordenação. Clique abre o **modal do corte** (`?clip=ID`), com anterior/próximo para aprovar em sequência. Ações rápidas na linha (Aprovar, Rejeitar, Publicar). |
| `/clipper/sessions` | **Sessões** | Lista compacta (estado, fonte, duração, cortes, saúde em uma frase). "Gravar pelo link" vira um botão que abre diálogo. |
| `/clipper/sessions/[id]` | **Detalhe da sessão** | O que hoje é o cartão da sessão (saúde, "agora na live", chat/transcrição/IA/cortes, gráfico, emotes, câmera, jogo, configuração do corte) e os cortes dela. |
| `/clipper/sources` | **Fontes** | Lista das fontes (streamers): ao vivo/offline, monitor (ligado / **pausado** / desligado), autorização, idioma da live, canais de publicação ligados. "Adicionar fonte" em diálogo. |
| `/clipper/games` | **Jogos** | O que a IA sabe dos jogos (como hoje). |
| `/clipper/settings` | **Ajustes** | Juiz (IA), estado do serviço e das ferramentas, transcrição, idioma padrão. |
A sidebar mostra os subitens do Clipador quando ele está ativo; a mesma sub-navegação aparece no topo
das páginas, com contadores (para aprovar, gravando agora). O editor em tela cheia (`/clipper/edit/[id]`)
fica fora desse quadro (grupo de rotas `(studio)`).
### Hierarquia visual
- Um bloco **"Ao vivo agora · N"** acima do conteúdo em todas as subpáginas enquanto algo grava: uma linha
fina por live (nome, relógio, chat, "Cortar agora", Parar só com ícone). Pensado para 5 canais no ar ao
mesmo tempo sem tomar a tela. É a única coisa que precisa estar sempre à mão.
- O "Resumo" com 4 cartões sai. O estado do serviço vira uma linha discreta ao lado da sub-navegação
(ponto verde/vermelho + texto) e o detalhe mora em Ajustes.
- Listas antes de cartões: a lista mostra o que decide (título, nota da IA, situação, fonte, duração,
estado); o modal mostra o resto (vídeo, veredito completo, sinais, legenda, ajuste de trecho, transcrição,
publicação).
### Sessão: parar é parar
Hoje o monitor da fonte reabre uma sessão nova 60 s depois de você parar à mão, porque a live continua no ar.
Regra nova:
- **Parar à mão pausa o monitor daquela fonte** (`channels.monitor_paused_at` + a sessão que motivou). O
monitor pula a fonte enquanto a pausa existir. A fonte aparece como "monitor pausado · você parou a sessão
#11" com o botão **Religar**. Ligar o switch "Monitorar" também limpa a pausa.
- No diálogo de parar há a opção "voltar a gravar sozinho quando a live cair e voltar": marcada, não pausa.
- Queda de live (captura cai sem ninguém pedir) continua sendo **retomada na mesma sessão** (`interrupted`
→ `keep_live`), como já era. Isso é o "caso caia, liga".
### Idioma e público (preparação para canais gringos)
- **Fonte** e **sessão** ganham `language` (idioma falado na live; padrão `CLIPPER_LANGUAGE`). A transcrição
(Whisper) usa o idioma da sessão; os prompts da IA recebem o idioma de saída (título, legenda, hashtags).
- **Canal de publicação** (`accounts`) ganha `language` (idioma/público: pt-BR, en-US, es-419…). O diálogo
"Publicar" avisa quando o idioma do corte difere do idioma do canal.
- Lista de cortes e sessões filtram por idioma. Versões traduzidas de um corte (legenda queimada e textos em
outro idioma a partir da mesma sessão) são a **próxima etapa**; o modelo já tem onde encaixar.
## Arquivos
- Dados compartilhados: `panel/src/components/clipper-provider.tsx` (contexto + consulta periódica).
- Moldura: `panel/src/components/clipper-shell.tsx` (cabeçalho compacto, sub-navegação, barra da live).
- Páginas: `panel/src/app/clipper/(studio)/…`.
- Serviço: `clipper/app/worker.py` (pausa do monitor), `db.py` (colunas novas), `main.py` (rotas/visões).
+82
View File
@@ -0,0 +1,82 @@
# IA do CenaForge — provedores, login e reserva
Três IAs, sempre pela **CLI oficial** instalada no PC (nunca SDK/HTTP direto):
| Provedor | CLI | Instalação (Windows) | Login com a conta (OAuth) | Chave de API (variável) |
|---|---|---|---|---|
| `claude` | Claude Code (`claude`) | `irm https://claude.ai/install.ps1 \| iex` | `claude auth login` | `ANTHROPIC_API_KEY` |
| `codex` | Codex (`codex`) | `npm install -g @openai/codex@latest` | `codex login` (ChatGPT) | `CODEX_API_KEY` (só no `codex exec`) |
| `gemini` | Gemini CLI (`gemini`) | `npm install -g @google/gemini-cli@latest` | `gemini` interativo → "Login with Google" | `GEMINI_API_KEY` |
> **Gemini + OAuth (verificado em 18/11/2026, gemini-cli 0.68.0):** o login gratuito "Gemini Code Assist for
> individuals" foi encerrado (`IneligibleTierError: UNSUPPORTED_CLIENT`, o Google manda migrar para o Antigravity).
> OAuth só funciona com plano elegível (Code Assist Standard/Enterprise, Workspace). Para conta pessoal, use a
> **chave de API** do Google AI Studio.
Quem usa: os **agentes do painel** (`panel/src/lib/agents.ts`) e o **juiz do Clipador** (`clipper/app/judge.py`).
A configuração fica no painel em **Configurações → IA** (`/settings/ai`).
## Arquivos compartilhados (contrato painel ↔ Clipador)
Ambos em `data/ai/`. Quem escreve é só o painel; o Clipador apenas lê (relê se o `mtime` mudar).
### `data/ai/settings.json` (sem segredo)
```json
{
"version": 1,
"providers": {
"claude": { "enabled": true, "authMode": "oauth" },
"codex": { "enabled": true, "authMode": "oauth" },
"gemini": { "enabled": false, "authMode": "apiKey" }
},
"order": ["claude", "codex", "gemini"],
"fallback": { "enabled": true, "cooldownMin": 15 }
}
```
- `enabled`: a IA pode ser usada (como principal ou reserva). Desligada, nunca é chamada.
- `authMode`: `"oauth"` = a sessão já logada da CLI; `"apiKey"` = a chave guardada no cofre.
- `order`: prioridade da **reserva**. A tarefa usa a IA escolhida (ou a preferida dela); se falhar por
indisponibilidade, tenta a próxima da lista que estiver ligada e pronta.
- `fallback.enabled`: liga a troca automática. `cooldownMin`: depois de uma falha de indisponibilidade, a IA fica
"em pausa" esse tempo e é pulada (cada processo guarda a sua pausa em memória).
- Arquivo ausente ou inválido = padrão acima, com `claude` e `codex` ligados em `oauth` e `gemini` desligado.
### `data/ai/vault.bin` (chaves de API)
Um JSON `{"claude": "sk-ant-…", "codex": "sk-…", "gemini": "AIza…"}` (só as que existirem) cifrado com a
**DPAPI do Windows**, escopo do usuário (`CurrentUser`), entropia `b"CenaForge.AI.vault.v1"`. O arquivo é o blob
cru da DPAPI. Só a mesma conta do Windows nesta máquina abre. A chave **nunca** volta para a tela: a API do painel
só diz se existe e os 4 últimos caracteres.
## Ambiente de cada chamada
Montado a partir do ambiente do processo, por provedor:
| Provedor | `authMode = "oauth"` | `authMode = "apiKey"` |
|---|---|---|
| `claude` | remove `ANTHROPIC_API_KEY` | `ANTHROPIC_API_KEY=<chave>` |
| `codex` | remove `CODEX_API_KEY` | `CODEX_API_KEY=<chave>` |
| `gemini` | `GOOGLE_GENAI_USE_GCA=true`, remove `GEMINI_API_KEY` | `GEMINI_API_KEY=<chave>`, remove `GOOGLE_GENAI_USE_GCA` |
Assim o login global de cada CLI não é tocado: o modo chave só vale para a chamada.
## O que conta como "indisponível" (dispara a reserva)
Falha que não é culpa do pedido: limite de uso ou cota (`rate limit`, `429`, `quota`, `usage limit`,
`credit balance`), sobrecarga (`overloaded`, `529`, `503`, `unavailable`), login ou chave (`401`, `403`,
`unauthorized`, `not logged in`, `invalid api key`, `IneligibleTier`), rede (`ECONN`, `ETIMEDOUT`, `ENOTFOUND`,
`network`), CLI que não iniciou ou não foi encontrada, e tempo esgotado. Erro de conteúdo (JSON inválido, schema)
**não** troca de IA.
## Gemini CLI em modo headless (0.68.0)
- Agente: `gemini -p <prompt> -o stream-json --approval-mode auto_edit --skip-trust [-m <modelo>] [--resume <sessão>]`.
- Eventos JSONL: `init {session_id, model}`, `message {role, content, delta}` (texto do assistente chega em
pedaços), `tool_use {tool_name, tool_id, parameters}`, `tool_result {tool_id, status, output, error}`,
`error {severity: warning|error, message}`, `result {status, error?, stats}`.
- Respostas estruturadas (juiz): `-o json` devolve `{"response": "<texto>", "stats": …}`; não há `--output-schema`,
então o schema vai no prompt e o JSON é extraído do texto. Leitura somente: `--approval-mode plan --skip-trust`, rodando numa pasta temporária fora do repositório (o `@arquivo` respeita o `.gitignore`).
- Modelos: `gemini models -o json` (não exige login).
- No Windows o npm instala `gemini.cmd`; rode `node <prefixo npm>/node_modules/@google/gemini-cli/bundle/gemini.js`.
+10 -1
View File
@@ -4,6 +4,7 @@ import { AccountCreateForm, AccountDetail } from "@/components/account-manager";
import { PlusIcon, PublishIcon, SettingsIcon, UsersIcon } from "@/components/icons"; import { PlusIcon, PublishIcon, SettingsIcon, UsersIcon } from "@/components/icons";
import { EmptyState, LinkButton, Meta, PageHeader, cx } from "@/components/ui"; import { EmptyState, LinkButton, Meta, PageHeader, cx } from "@/components/ui";
import { listAccounts, type AccountView } from "@/lib/accounts"; import { listAccounts, type AccountView } from "@/lib/accounts";
import { languageLabel, languageShort } from "@/lib/languages";
import { listStories } from "@/lib/stories"; import { listStories } from "@/lib/stories";
export const metadata = { title: "Canais de publicação" }; export const metadata = { title: "Canais de publicação" };
@@ -30,7 +31,7 @@ export default async function AccountsPage({ searchParams }: { searchParams: Pro
description="Cada canal reúne os seus perfis no YouTube, no TikTok e no Instagram. Ligue histórias e fontes de corte a ele: o que você aprovar sai nas redes do canal." description="Cada canal reúne os seus perfis no YouTube, no TikTok e no Instagram. Ligue histórias e fontes de corte a ele: o que você aprovar sai nas redes do canal."
meta={<> meta={<>
<Meta icon={<PublishIcon size={15} />}>Fila e horários em <Link href="/publishing" className="text-fg-muted underline underline-offset-2 hover:text-fg">Publicações</Link></Meta> <Meta icon={<PublishIcon size={15} />}>Fila e horários em <Link href="/publishing" className="text-fg-muted underline underline-offset-2 hover:text-fg">Publicações</Link></Meta>
<Meta icon={<SettingsIcon size={15} />}>Apps das redes e horários bons em <Link href="/settings" className="text-fg-muted underline underline-offset-2 hover:text-fg">Configurações</Link></Meta> <Meta icon={<SettingsIcon size={15} />}>Apps das redes e horários bons em <Link href="/settings/publishing" className="text-fg-muted underline underline-offset-2 hover:text-fg">Configurações</Link></Meta>
</>} /> </>} />
<div className="grid gap-6"> <div className="grid gap-6">
@@ -57,6 +58,8 @@ export default async function AccountsPage({ searchParams }: { searchParams: Pro
/** Um chip por canal (com ponto de alerta se alguma rede pede atenção) e o botão "Novo canal". */ /** Um chip por canal (com ponto de alerta se alguma rede pede atenção) e o botão "Novo canal". */
function AccountPicker({ accounts, selectedId, creating }: { accounts: AccountView[]; selectedId?: string; creating: boolean }) { function AccountPicker({ accounts, selectedId, creating }: { accounts: AccountView[]; selectedId?: string; creating: boolean }) {
// Sigla do idioma só quando há canais em idiomas diferentes (todos em português: não polui).
const mixedLanguages = new Set(accounts.map((a) => a.language)).size > 1;
return ( return (
<nav aria-label="Canais de publicação" className="flex flex-wrap items-center gap-x-3 gap-y-3 border-b border-line pb-5"> <nav aria-label="Canais de publicação" className="flex flex-wrap items-center gap-x-3 gap-y-3 border-b border-line pb-5">
<ul className="flex min-w-0 flex-wrap gap-2"> <ul className="flex min-w-0 flex-wrap gap-2">
@@ -70,6 +73,12 @@ function AccountPicker({ accounts, selectedId, creating }: { accounts: AccountVi
className={cx("inline-flex h-10 max-w-[20rem] items-center gap-2 rounded-full border px-4 text-sm font-medium transition-colors", className={cx("inline-flex h-10 max-w-[20rem] items-center gap-2 rounded-full border px-4 text-sm font-medium transition-colors",
current ? "border-accent/60 bg-accent-soft text-fg" : "border-line-strong bg-surface text-fg-muted hover:bg-raised hover:text-fg")}> current ? "border-accent/60 bg-accent-soft text-fg" : "border-line-strong bg-surface text-fg-muted hover:bg-raised hover:text-fg")}>
<span className="truncate">{a.name}</span> <span className="truncate">{a.name}</span>
{mixedLanguages && (
<span className="rounded-full border border-line-strong px-1.5 text-[0.625rem] font-semibold tracking-wide text-fg-subtle"
title={languageLabel(a.language)}>
{languageShort(a.language)}<span className="sr-only"> ({languageLabel(a.language)})</span>
</span>
)}
{attention > 0 && <> {attention > 0 && <>
<span aria-hidden="true" className="size-2 shrink-0 rounded-full bg-warning" /> <span aria-hidden="true" className="size-2 shrink-0 rounded-full bg-warning" />
<span className="sr-only">({attention === 1 ? "uma rede precisa" : `${attention} redes precisam`} de atenção)</span> <span className="sr-only">({attention === 1 ? "uma rede precisa" : `${attention} redes precisam`} de atenção)</span>
+2 -2
View File
@@ -7,7 +7,7 @@ import { addManualComments, closeDecision, decisionVotes } from "@/lib/decisions
import { defaultModelFor, defaultProviderFor, startRun } from "@/lib/agents"; import { defaultModelFor, defaultProviderFor, startRun } from "@/lib/agents";
import { slugify } from "@/lib/paths"; import { slugify } from "@/lib/paths";
import { UserError, createEpisode, createStory, deleteStory, getEpisodeById, getStory, provisionalTitle } from "@/lib/stories"; import { UserError, createEpisode, createStory, deleteStory, getEpisodeById, getStory, provisionalTitle } from "@/lib/stories";
import { CHOICES, type Choice, type Provider, type StoryKind } from "@/lib/types"; import { CHOICES, PROVIDERS, type Choice, type Provider, type StoryKind } from "@/lib/types";
export type FormState = { error?: string; message?: string } | null; export type FormState = { error?: string; message?: string } | null;
@@ -55,7 +55,7 @@ export async function createStoryFromTextAction(_prev: FormState, form: FormData
// Documental é um vídeo só: sem título de episódio ("Abertura" só faz sentido numa série). // Documental é um vídeo só: sem título de episódio ("Abertura" só faz sentido numa série).
const ep = createEpisode(story.id, { title: kind === "documentary" ? "" : "Abertura" }); const ep = createEpisode(story.id, { title: kind === "documentary" ? "" : "Abertura" });
const chosen = String(form.get("provider") ?? ""); const chosen = String(form.get("provider") ?? "");
const provider: Provider = chosen === "claude" || chosen === "codex" ? chosen : defaultProviderFor("story"); const provider: Provider = (PROVIDERS as string[]).includes(chosen) ? (chosen as Provider) : defaultProviderFor("story");
// Modelo escolhido no formulário; vazio = padrão da tarefa (no Codex, o do config.toml). startRun valida. // Modelo escolhido no formulário; vazio = padrão da tarefa (no Codex, o do config.toml). startRun valida.
const model = String(form.get("model") ?? "") || defaultModelFor("story", provider); const model = String(form.get("model") ?? "") || defaultModelFor("story", provider);
const run = startRun({ const run = startRun({
+2 -2
View File
@@ -24,13 +24,13 @@ export default async function AgentPage({ searchParams }: { searchParams: Promis
const defaults: AgentDefaults = { const defaults: AgentDefaults = {
provider: map(defaultProviderFor), provider: map(defaultProviderFor),
preferred: PREFERRED_PROVIDER, preferred: PREFERRED_PROVIDER,
model: map((k) => ({ claude: defaultModelFor(k, "claude"), codex: defaultModelFor(k, "codex") })), model: map((k) => ({ claude: defaultModelFor(k, "claude"), codex: defaultModelFor(k, "codex"), gemini: defaultModelFor(k, "gemini") })),
}; };
return ( return (
<> <>
<PageHeader eyebrow="Agentes de código" title="Console do agente" <PageHeader eyebrow="Agentes de código" title="Console do agente"
description="Peça uma história, um roteiro, uma cena ou um ajuste. Enredo e roteiro saem com o GPT (Codex); a cena, com o Claude. Um agente roda por vez, sempre dentro do projeto." /> description="Peça uma história, um roteiro, uma cena ou um ajuste. Enredo e roteiro saem com o GPT (Codex); a cena, com o Claude. Se uma IA cair, a reserva assume (Configurações → IA). Um agente roda por vez, sempre dentro do projeto." />
<div className="grid items-start gap-8 xl:grid-cols-[minmax(0,1fr)_20rem] 2xl:grid-cols-[minmax(0,1fr)_26rem]"> <div className="grid items-start gap-8 xl:grid-cols-[minmax(0,1fr)_20rem] 2xl:grid-cols-[minmax(0,1fr)_26rem]">
<AgentConsole <AgentConsole
key={runId ?? "novo"} key={runId ?? "novo"}
+2 -2
View File
@@ -6,10 +6,10 @@ export async function GET(_request: Request, ctx: { params: Promise<{ id: string
return account ? Response.json(account) : Response.json({ error: "Canal de publicação não encontrado." }, { status: 404 }); return account ? Response.json(account) : Response.json({ error: "Canal de publicação não encontrado." }, { status: 404 });
} }
/** Edita nome, nicho, notas e regras: {name?, niche?, notes?, approvalMode?: "manual"|"auto", timing?: "now"|"best_slot", aiLabel?: "auto"|"always"|"never"}. */ /** Edita nome, nicho, notas, idioma e regras: {name?, niche?, notes?, language?: "pt-BR"|"en-US"|"es-419", approvalMode?: "manual"|"auto", timing?: "now"|"best_slot", aiLabel?: "auto"|"always"|"never"}. */
export async function PATCH(request: Request, ctx: { params: Promise<{ id: string }> }) { export async function PATCH(request: Request, ctx: { params: Promise<{ id: string }> }) {
try { try {
const body = await readJson<{ name: string; niche: string; notes: string; approvalMode: string; timing: string; aiLabel: string }>(request); const body = await readJson<{ name: string; niche: string; notes: string; language: string; approvalMode: string; timing: string; aiLabel: string }>(request);
return Response.json(updateAccount((await ctx.params).id, body)); return Response.json(updateAccount((await ctx.params).id, body));
} catch (error) { } catch (error) {
return errorResponse(error); return errorResponse(error);
+3 -3
View File
@@ -7,11 +7,11 @@ export async function GET() {
return Response.json(listAccounts(), { headers: { "Cache-Control": "no-store" } }); return Response.json(listAccounts(), { headers: { "Cache-Control": "no-store" } });
} }
/** Cria uma conta: {name, niche?, notes?}. */ /** Cria uma conta: {name, niche?, notes?, language?: "pt-BR"|"en-US"|"es-419"}. */
export async function POST(request: Request) { export async function POST(request: Request) {
try { try {
const body = (await request.json()) as { name?: string; niche?: string; notes?: string }; const body = (await request.json()) as { name?: string; niche?: string; notes?: string; language?: string };
return Response.json(createAccount({ name: String(body.name ?? ""), niche: body.niche, notes: body.notes })); return Response.json(createAccount({ name: String(body.name ?? ""), niche: body.niche, notes: body.notes, language: body.language }));
} catch (error) { } catch (error) {
return errorResponse(error); return errorResponse(error);
} }
+75
View File
@@ -0,0 +1,75 @@
import { clearCooldown, openLoginTerminal, providerStatus, readAiSettings, setApiKey, startInstall, testProvider } from "@/lib/ai";
import { errorResponse, readJson } from "@/lib/http";
import { UserError } from "@/lib/stories";
import { PROVIDERS, type Provider } from "@/lib/types";
export const dynamic = "force-dynamic";
type Ctx = { params: Promise<{ provider: string }> };
async function mustProvider(ctx: Ctx): Promise<Provider> {
const id = (await ctx.params).provider;
if (!(PROVIDERS as string[]).includes(id)) throw new UserError("IA desconhecida.");
return id as Provider;
}
const payload = (refresh = false) => ({ settings: readAiSettings(), providers: providerStatus({ refresh }) });
/**
* Ações de uma IA: {action: "install" | "login" | "verify" | "test" | "resume"}.
* install — instala/atualiza a CLI em segundo plano (o log vem no GET /api/ai);
* login — abre um terminal com o login da CLI (OAuth no navegador);
* verify — refaz a detecção (depois do login ou da instalação);
* test — pergunta mínima para confirmar login/chave/cota (devolve {test});
* resume — tira a IA da pausa da reserva.
*/
export async function POST(request: Request, ctx: Ctx) {
try {
const id = await mustProvider(ctx);
const { action } = await readJson<{ action: string }>(request);
switch (action) {
case "install":
startInstall(id);
return Response.json(payload());
case "login":
openLoginTerminal(id);
return Response.json(payload());
case "verify":
return Response.json(payload(true));
case "test": {
const test = await testProvider(id);
return Response.json({ ...payload(), test });
}
case "resume":
clearCooldown(id);
return Response.json(payload());
default:
throw new UserError("Ação inválida.");
}
} catch (error) {
return errorResponse(error);
}
}
/** Guarda a chave de API no cofre (DPAPI): {apiKey}. A resposta nunca traz a chave, só os 4 últimos caracteres. */
export async function PUT(request: Request, ctx: Ctx) {
try {
const id = await mustProvider(ctx);
const { apiKey } = await readJson<{ apiKey: string }>(request);
if (typeof apiKey !== "string") throw new UserError("Cole a chave de API.");
setApiKey(id, apiKey);
return Response.json(payload());
} catch (error) {
return errorResponse(error);
}
}
/** Apaga a chave de API desta IA do cofre. */
export async function DELETE(_request: Request, ctx: Ctx) {
try {
setApiKey(await mustProvider(ctx), null);
return Response.json(payload());
} catch (error) {
return errorResponse(error);
}
}
+24
View File
@@ -0,0 +1,24 @@
import { providerStatus, readAiSettings, updateAiSettings, type AiSettingsPatch } from "@/lib/ai";
import { errorResponse, readJson } from "@/lib/http";
export const dynamic = "force-dynamic";
/** Estado das IAs: {settings, providers}. `?refresh=1` refaz a detecção (instalada, versão, login) na hora. */
export async function GET(request: Request) {
try {
const refresh = new URL(request.url).searchParams.get("refresh") === "1";
return Response.json({ settings: readAiSettings(), providers: providerStatus({ refresh }) }, { headers: { "Cache-Control": "no-store" } });
} catch (error) {
return errorResponse(error);
}
}
/** Atualiza só o que vier: {providers?: {<ia>?: {enabled?, authMode?}}, order?: [...], fallback?: {enabled?, cooldownMin?}}. */
export async function PUT(request: Request) {
try {
const settings = updateAiSettings(await readJson<AiSettingsPatch>(request));
return Response.json({ settings, providers: providerStatus() });
} catch (error) {
return errorResponse(error);
}
}
+2 -2
View File
@@ -5,7 +5,7 @@ import { defaultModelFor, defaultProviderFor, startRun } from "@/lib/agents";
import { errorResponse } from "@/lib/http"; import { errorResponse } from "@/lib/http";
import { slugify } from "@/lib/paths"; import { slugify } from "@/lib/paths";
import { UserError, createEpisode, createStory, getStory, provisionalTitle } from "@/lib/stories"; import { UserError, createEpisode, createStory, getStory, provisionalTitle } from "@/lib/stories";
import { STORY_KINDS, type Provider, type StoryKind } from "@/lib/types"; import { PROVIDERS, STORY_KINDS, type Provider, type StoryKind } from "@/lib/types";
export async function POST(request: Request) { export async function POST(request: Request) {
try { try {
@@ -20,7 +20,7 @@ export async function POST(request: Request) {
for (let n = 2; getStory(id); n++) id = `${base}-${n}`; for (let n = 2; getStory(id); n++) id = `${base}-${n}`;
const story = createStory({ title, id, logline: "", kind, branchCount: 2 }); const story = createStory({ title, id, logline: "", kind, branchCount: 2 });
const ep = createEpisode(story.id, { title: kind === "documentary" ? "" : "Abertura" }); const ep = createEpisode(story.id, { title: kind === "documentary" ? "" : "Abertura" });
const provider: Provider = body.provider === "claude" || body.provider === "codex" ? body.provider : defaultProviderFor("story"); const provider: Provider = PROVIDERS.includes(body.provider as Provider) ? (body.provider as Provider) : defaultProviderFor("story");
const model = String(body.model ?? "") || defaultModelFor("story", provider); const model = String(body.model ?? "") || defaultModelFor("story", provider);
const run = startRun({ provider, model, kind: "story", request: text, storyId: story.id, episodeId: ep.id }); const run = startRun({ provider, model, kind: "story", request: text, storyId: story.id, episodeId: ep.id });
return Response.json({ storyId: story.id, episodeId: ep.id, runId: run.id }); return Response.json({ storyId: story.id, episodeId: ep.id, runId: run.id });
@@ -0,0 +1,9 @@
import { GamesPage } from "@/components/clipper-games-page";
import { ClipperGate } from "@/components/clipper-provider";
export const metadata = { title: "Jogos · Clipador" };
/** O que a IA sabe dos jogos das lives. Cabeçalho, barra da live e sub-navegação vêm do layout. */
export default function ClipperGamesPage() {
return <ClipperGate><GamesPage /></ClipperGate>;
}
+27
View File
@@ -0,0 +1,27 @@
import { connection } from "next/server";
import type { ReactNode } from "react";
import type { ChannelAccounts } from "@/components/clipper-channels";
import { ClipperProvider } from "@/components/clipper-provider";
import { ClipperShell } from "@/components/clipper-shell";
import { listAccounts } from "@/lib/accounts";
/**
* Moldura comum das subpáginas do Clipador (Cortes, Sessões, Fontes, Jogos, Ajustes): os dados do serviço são
* lidos no navegador (mudam a cada segundo) e compartilhados pelo ClipperProvider; do servidor vem só em quais
* canais de publicação cada fonte está ligada. O editor em tela cheia (/clipper/edit) fica fora deste grupo.
*/
export default async function ClipperStudioLayout({ children }: { children: ReactNode }) {
await connection();
const channelAccounts: ChannelAccounts = {};
for (const account of listAccounts()) {
for (const link of account.channels) {
if (link.status !== "active") continue;
(channelAccounts[link.channel_id] ??= []).push({ id: account.id, name: account.name });
}
}
return (
<ClipperProvider channelAccounts={channelAccounts}>
<ClipperShell>{children}</ClipperShell>
</ClipperProvider>
);
}
+13
View File
@@ -0,0 +1,13 @@
import { ClipsPage } from "@/components/clipper-clips-page";
import { ClipperGate } from "@/components/clipper-provider";
export const metadata = { title: "Cortes · Clipador" };
/** Cortes do Clipador: lista com filtros e o modal do corte. Cabeçalho, barra da live e sub-navegação vêm do layout. */
export default function ClipperClipsPage() {
return (
<ClipperGate>
<ClipsPage />
</ClipperGate>
);
}
@@ -0,0 +1,14 @@
import { ClipperGate } from "@/components/clipper-provider";
import { SessionDetailPage } from "@/components/clipper-session-detail";
export const metadata = { title: "Sessão · Clipador" };
/** Detalhe de uma sessão do Clipador. A sessão vem dos dados já carregados pelo provider (id fora da lista = não encontrada). */
export default async function ClipperSessionPage({ params }: { params: Promise<{ id: string }> }) {
const { id } = await params;
return (
<ClipperGate>
<SessionDetailPage id={Number(id)} />
</ClipperGate>
);
}
@@ -0,0 +1,13 @@
import { ClipperGate } from "@/components/clipper-provider";
import { SessionsPage } from "@/components/clipper-sessions-page";
export const metadata = { title: "Sessões · Clipador" };
/** Sessões do Clipador: lista compacta; o cabeçalho, a barra da live e a sub-navegação vêm do layout do grupo. */
export default function ClipperSessionsPage() {
return (
<ClipperGate>
<SessionsPage />
</ClipperGate>
);
}
@@ -0,0 +1,9 @@
import { ClipperGate } from "@/components/clipper-provider";
import { SettingsPage } from "@/components/clipper-settings-page";
export const metadata = { title: "Ajustes · Clipador" };
/** Ajustes do Clipador: juiz (IA), serviço e idiomas. Cabeçalho, barra da live e sub-navegação vêm do layout. */
export default function ClipperSettingsPage() {
return <ClipperGate><SettingsPage /></ClipperGate>;
}
@@ -0,0 +1,9 @@
import { SourcesPage } from "@/components/clipper-channels";
import { ClipperGate } from "@/components/clipper-provider";
export const metadata = { title: "Fontes · Clipador" };
/** Fontes do Clipador: os streamers de onde saem os cortes. Cabeçalho, barra da live e sub-navegação vêm do layout. */
export default function ClipperSourcesPage() {
return <ClipperGate><SourcesPage /></ClipperGate>;
}
-39
View File
@@ -1,39 +0,0 @@
import { connection } from "next/server";
import type { ChannelAccounts } from "@/components/clipper-channels";
import { ClipperStudio } from "@/components/clipper-studio";
import Link from "next/link";
import { BroadcastIcon, PublishIcon, ScissorsIcon, SparkIcon } from "@/components/icons";
import { Meta, PageHeader } from "@/components/ui";
import { listAccounts } from "@/lib/accounts";
export const metadata = { title: "Clipador" };
/**
* Clipador: cortes automáticos de lives (Twitch, YouTube, Kick). O estado muda a cada segundo
* (gravação, IA, render), então a página busca /api/clipper/* no navegador e consulta de novo
* enquanto houver trabalho. Do servidor vem só em quais canais de publicação cada fonte está ligada.
*/
export default async function ClipperPage() {
await connection();
const channelAccounts: ChannelAccounts = {};
for (const account of listAccounts()) {
for (const link of account.channels) {
if (link.status !== "active") continue;
(channelAccounts[link.channel_id] ??= []).push({ id: account.id, name: account.name });
}
}
return (
<>
<PageHeader eyebrow="Cortes de live" title="Clipador"
description="Grava lives de terceiros, acha os picos de reação do chat, pede o veredito da IA e entrega cortes verticais com legenda, prontos para você aprovar."
meta={<>
<Meta icon={<BroadcastIcon size={15} />}>Twitch, YouTube e Kick</Meta>
<Meta icon={<SparkIcon size={15} />}>Juiz: Codex ou Claude pela CLI</Meta>
<Meta icon={<ScissorsIcon size={15} />}>MP4 1080×1920 com legenda</Meta>
<Meta icon={<PublishIcon size={15} />}>Cortes aprovados saem nas redes dos <Link href="/accounts" className="text-fg-muted underline underline-offset-2 hover:text-fg">canais de publicação</Link></Meta>
</>} />
<ClipperStudio channelAccounts={channelAccounts} />
</>
);
}
+12
View File
@@ -219,6 +219,18 @@
transition-delay: 110ms; transition-delay: 110ms;
} }
/* Subpáginas na barra: fechadas (0fr) com a barra recolhida, abertas (1fr) quando ela expande. */
.rail-sub {
display: grid;
grid-template-rows: 0fr;
transition: grid-template-rows 200ms cubic-bezier(0.2, 0.8, 0.2, 1);
}
.rail:hover .rail-sub,
.rail:has(:focus-visible) .rail-sub {
grid-template-rows: 1fr;
}
/* Texto com o degradê da chama, para o que é feito pela IA */ /* Texto com o degradê da chama, para o que é feito pela IA */
.text-flame { .text-flame {
background: linear-gradient(95deg, var(--color-glow), var(--color-accent) 45%, var(--color-flame)); background: linear-gradient(95deg, var(--color-glow), var(--color-accent) 45%, var(--color-flame));
+2 -2
View File
@@ -10,7 +10,7 @@ import {
} from "@/components/ui"; } from "@/components/ui";
import { defaultProviderFor, models, providers } from "@/lib/agents"; import { defaultProviderFor, models, providers } from "@/lib/agents";
import { listEpisodes, listStories } from "@/lib/stories"; import { listEpisodes, listStories } from "@/lib/stories";
import type { EpisodeView, Story } from "@/lib/types"; import type { EpisodeView, Provider, Story } from "@/lib/types";
export default async function HomePage() { export default async function HomePage() {
await connection(); await connection();
@@ -18,7 +18,7 @@ export default async function HomePage() {
const totalEpisodes = stories.reduce((sum, s) => sum + s.episodes.length, 0); const totalEpisodes = stories.reduce((sum, s) => sum + s.episodes.length, 0);
const rendered = stories.reduce((sum, s) => sum + s.episodes.filter((e) => e.stage === "renderizado" || e.stage === "decidido").length, 0); const rendered = stories.reduce((sum, s) => sum + s.episodes.filter((e) => e.stage === "renderizado" || e.stage === "decidido").length, 0);
const openVotes = stories.reduce((sum, s) => sum + (s.story.kind === "interactive" ? s.episodes.filter((e) => e.stage === "renderizado").length : 0), 0); const openVotes = stories.reduce((sum, s) => sum + (s.story.kind === "interactive" ? s.episodes.filter((e) => e.stage === "renderizado").length : 0), 0);
const available = Object.fromEntries(providers().map((p) => [p.id, p.available])) as Record<"claude" | "codex", boolean>; const available = Object.fromEntries(providers().map((p) => [p.id, p.available])) as Record<Provider, boolean>;
return ( return (
<> <>
+1 -1
View File
@@ -16,7 +16,7 @@ export default function PublishingPage() {
description="Tudo o que vai para as redes: o que espera a sua aprovação, o que está agendado, o que está saindo agora e o que já foi publicado." description="Tudo o que vai para as redes: o que espera a sua aprovação, o que está agendado, o que está saindo agora e o que já foi publicado."
meta={<> meta={<>
<Meta icon={<PublishIcon size={15} />}>Redes e regras em <Link href="/accounts" className="text-fg-muted underline underline-offset-2 hover:text-fg">Canais de publicação</Link></Meta> <Meta icon={<PublishIcon size={15} />}>Redes e regras em <Link href="/accounts" className="text-fg-muted underline underline-offset-2 hover:text-fg">Canais de publicação</Link></Meta>
<Meta icon={<ClockIcon size={15} />}>Horários bons em <Link href="/settings" className="text-fg-muted underline underline-offset-2 hover:text-fg">Configurações</Link></Meta> <Meta icon={<ClockIcon size={15} />}>Horários bons em <Link href="/settings/publishing" className="text-fg-muted underline underline-offset-2 hover:text-fg">Configurações</Link></Meta>
<Meta icon={<SettingsIcon size={15} />}>O painel precisa estar aberto para publicar</Meta> <Meta icon={<SettingsIcon size={15} />}>O painel precisa estar aberto para publicar</Meta>
</>} /> </>} />
<PublishingBoard /> <PublishingBoard />
+7
View File
@@ -0,0 +1,7 @@
import { AiSettings } from "@/components/ai-settings";
export const metadata = { title: "IA · Configurações" };
export default function Page() {
return <AiSettings />;
}
+7
View File
@@ -0,0 +1,7 @@
import { AppsTab } from "@/components/settings-panel";
export const metadata = { title: "Apps das redes · Configurações" };
export default function Page() {
return <AppsTab />;
}
+7
View File
@@ -0,0 +1,7 @@
import { BrowserTab } from "@/components/settings-panel";
export const metadata = { title: "Navegador · Configurações" };
export default function Page() {
return <BrowserTab />;
}
+9
View File
@@ -0,0 +1,9 @@
import type { ReactNode } from "react";
import { SettingsShell } from "@/components/settings-shell";
export const metadata = { title: "Configurações" };
/** Moldura comum das subpáginas de Configurações (IA, Publicação, Apps das redes, Navegador, Sobre os modos). */
export default function SettingsLayout({ children }: { children: ReactNode }) {
return <SettingsShell>{children}</SettingsShell>;
}
+7
View File
@@ -0,0 +1,7 @@
import { ModesTab } from "@/components/settings-panel";
export const metadata = { title: "Sobre os modos · Configurações" };
export default function Page() {
return <ModesTab />;
}
+3 -12
View File
@@ -1,15 +1,6 @@
import { SettingsPanel } from "@/components/settings-panel"; import { redirect } from "next/navigation";
import { PageHeader } from "@/components/ui";
export const metadata = { title: "Configurações" }; /** /settings abre a primeira seção (IA); cada seção tem a própria página. */
/** Configurações do painel: publicação, apps das redes, navegador da sessão logada e a explicação dos modos. */
export default function SettingsPage() { export default function SettingsPage() {
return ( redirect("/settings/ai");
<>
<PageHeader eyebrow="Painel" title="Configurações"
description="Horários de publicação, os apps de cada rede e o navegador usado na sessão logada. Tudo fica só neste computador." />
<SettingsPanel />
</>
);
} }
@@ -0,0 +1,7 @@
import { PublishingTab } from "@/components/settings-panel";
export const metadata = { title: "Publicação · Configurações" };
export default function Page() {
return <PublishingTab />;
}
+27 -4
View File
@@ -9,12 +9,14 @@ import Link from "next/link";
import { useRouter } from "next/navigation"; import { useRouter } from "next/navigation";
import { useEffect, useId, useState, useTransition, type FormEvent, type ReactNode } from "react"; import { useEffect, useId, useState, useTransition, type FormEvent, type ReactNode } from "react";
import type { AccountView } from "@/lib/accounts"; import type { AccountView } from "@/lib/accounts";
import { ACCOUNT_LANGUAGES, DEFAULT_LANGUAGE, languageLabel, languageShort } from "@/lib/languages";
import { PLATFORMS, type StoryKind } from "@/lib/types"; import { PLATFORMS, type StoryKind } from "@/lib/types";
import { apiCall } from "./api-client"; import { apiCall } from "./api-client";
import { PLATFORM_LABEL, clipperCall, isOfflineError, type ClipperChannel } from "./clipper-client"; import { PLATFORM_LABEL, clipperCall, isOfflineError, type ClipperChannel } from "./clipper-client";
import { PlatformIcon } from "./clipper-sessions"; import { PlatformIcon } from "./clipper-sessions";
import { PublishingNetworksCard, PublishingRulesCard, networkAnchor } from "./account-networks"; import { PublishingNetworksCard, PublishingRulesCard, networkAnchor } from "./account-networks";
import { Dialog } from "./dialog"; import { Dialog } from "./dialog";
import { DescribedSelect } from "./forms";
import { AlertIcon, ChartIcon, FilmIcon, LinkIcon, PenIcon, PlusIcon, PublishIcon, ScissorsIcon, TrashIcon, XIcon } from "./icons"; import { AlertIcon, ChartIcon, FilmIcon, LinkIcon, PenIcon, PlusIcon, PublishIcon, ScissorsIcon, TrashIcon, XIcon } from "./icons";
import { PLATFORM_META } from "./platforms"; import { PLATFORM_META } from "./platforms";
import { readNetwork } from "./publishing-client"; import { readNetwork } from "./publishing-client";
@@ -23,6 +25,9 @@ import { storyFormatLabel } from "./story-formats";
import { Badge, Button, Card, Eyebrow, Feedback, Field, Input, LinkButton, Select, Spinner, Textarea, cx, formatDate, type Tone } from "./ui"; import { Badge, Button, Card, Eyebrow, Feedback, Field, Input, LinkButton, Select, Spinner, Textarea, cx, formatDate, type Tone } from "./ui";
import { askConfirm } from "./confirm-dialog"; import { askConfirm } from "./confirm-dialog";
/** Opções do seletor "Idioma e público" (criar e editar canal). */
const LANGUAGE_OPTIONS = ACCOUNT_LANGUAGES.map((l) => ({ value: l.id, label: l.label, description: l.audience }));
type StoryOption = { id: string; title: string; kind: StoryKind }; type StoryOption = { id: string; title: string; kind: StoryKind };
/** `key` diz qual ação gerou o retorno, para mostrá-lo perto de onde o clique aconteceu. */ /** `key` diz qual ação gerou o retorno, para mostrá-lo perto de onde o clique aconteceu. */
type Message = { ok: boolean; text: string; key: string } | null; type Message = { ok: boolean; text: string; key: string } | null;
@@ -69,6 +74,7 @@ export function AccountCreateForm() {
await run<AccountView>("create", await run<AccountView>("create",
() => apiCall<AccountView>("/api/accounts", "POST", { () => apiCall<AccountView>("/api/accounts", "POST", {
name: String(form.get("name") ?? ""), niche: String(form.get("niche") ?? ""), notes: String(form.get("notes") ?? ""), name: String(form.get("name") ?? ""), niche: String(form.get("niche") ?? ""), notes: String(form.get("notes") ?? ""),
language: String(form.get("language") ?? DEFAULT_LANGUAGE),
}), }),
(a) => `Canal “${a.name}” criado.`, (a) => `Canal “${a.name}” criado.`,
(a) => router.push(`/accounts?account=${encodeURIComponent(a.id)}`)); (a) => router.push(`/accounts?account=${encodeURIComponent(a.id)}`));
@@ -84,6 +90,8 @@ export function AccountCreateForm() {
<Field label="Nicho (opcional)"> <Field label="Nicho (opcional)">
<Input name="niche" maxLength={60} placeholder="Ex.: suspense leve, humor" /> <Input name="niche" maxLength={60} placeholder="Ex.: suspense leve, humor" />
</Field> </Field>
{/* Idioma e público: para quem o canal fala (os cortes e textos precisam estar nesse idioma). */}
<DescribedSelect name="language" label="Idioma e público" defaultValue={DEFAULT_LANGUAGE} options={LANGUAGE_OPTIONS} />
<Field label="Notas (opcional)"> <Field label="Notas (opcional)">
<Textarea name="notes" rows={3} maxLength={500} placeholder="Público, horários de postagem, combinados…" /> <Textarea name="notes" rows={3} maxLength={500} placeholder="Público, horários de postagem, combinados…" />
</Field> </Field>
@@ -112,6 +120,7 @@ export function AccountDetail({ account, stories }: { account: AccountView; stor
const form = new FormData(e.currentTarget); const form = new FormData(e.currentTarget);
const ok = await run("save", () => apiCall<AccountView>(base, "PATCH", { const ok = await run("save", () => apiCall<AccountView>(base, "PATCH", {
name: String(form.get("name") ?? ""), niche: String(form.get("niche") ?? ""), notes: String(form.get("notes") ?? ""), name: String(form.get("name") ?? ""), niche: String(form.get("niche") ?? ""), notes: String(form.get("notes") ?? ""),
language: String(form.get("language") ?? account.language),
}), "Dados do canal salvos."); }), "Dados do canal salvos.");
if (ok) setEditing(false); if (ok) setEditing(false);
} }
@@ -171,7 +180,7 @@ export function AccountDetail({ account, stories }: { account: AccountView; stor
</div> </div>
<Dialog open={editing} onClose={() => setEditing(false)} size="sm" eyebrow="Canal de publicação" title="Editar dados do canal" <Dialog open={editing} onClose={() => setEditing(false)} size="sm" eyebrow="Canal de publicação" title="Editar dados do canal"
description="Nome, nicho e notas. Não mexe nas redes nem no que o canal publica." description="Nome, nicho, idioma e notas. Não mexe nas redes nem no que o canal publica."
footer={<> footer={<>
<Button type="button" variant="ghost" onClick={() => setEditing(false)}>Cancelar</Button> <Button type="button" variant="ghost" onClick={() => setEditing(false)}>Cancelar</Button>
<Button type="submit" form={formId} disabled={pending !== null}>{pending === "save" ? <><Spinner />Salvando…</> : "Salvar dados"}</Button> <Button type="submit" form={formId} disabled={pending !== null}>{pending === "save" ? <><Spinner />Salvando…</> : "Salvar dados"}</Button>
@@ -179,6 +188,7 @@ export function AccountDetail({ account, stories }: { account: AccountView; stor
<form id={formId} key={account.updated_at} onSubmit={save} className="grid gap-4"> <form id={formId} key={account.updated_at} onSubmit={save} className="grid gap-4">
<Field label="Nome"><Input name="name" required minLength={2} maxLength={60} defaultValue={account.name} autoFocus /></Field> <Field label="Nome"><Input name="name" required minLength={2} maxLength={60} defaultValue={account.name} autoFocus /></Field>
<Field label="Nicho"><Input name="niche" maxLength={60} defaultValue={account.niche} placeholder="Ex.: suspense leve" /></Field> <Field label="Nicho"><Input name="niche" maxLength={60} defaultValue={account.niche} placeholder="Ex.: suspense leve" /></Field>
<DescribedSelect name="language" label="Idioma e público" defaultValue={account.language || DEFAULT_LANGUAGE} options={LANGUAGE_OPTIONS} />
<Field label="Notas"><Textarea name="notes" rows={4} maxLength={500} defaultValue={account.notes} /></Field> <Field label="Notas"><Textarea name="notes" rows={4} maxLength={500} defaultValue={account.notes} /></Field>
<div aria-live="polite" className="empty:hidden">{saveMessage && !saveMessage.ok && <Feedback ok={false}>{saveMessage.text}</Feedback>}</div> <div aria-live="polite" className="empty:hidden">{saveMessage && !saveMessage.ok && <Feedback ok={false}>{saveMessage.text}</Feedback>}</div>
</form> </form>
@@ -211,9 +221,15 @@ function AccountHeader({ account, activeStories, activeChannels, onEdit }: {
<div className="min-w-0"> <div className="min-w-0">
<Eyebrow className="mb-2">Canal de publicação</Eyebrow> <Eyebrow className="mb-2">Canal de publicação</Eyebrow>
<h2 id={titleId} className="font-display text-[1.75rem] leading-tight font-semibold tracking-[-0.02em] break-words text-fg">{account.name}</h2> <h2 id={titleId} className="font-display text-[1.75rem] leading-tight font-semibold tracking-[-0.02em] break-words text-fg">{account.name}</h2>
<p className="mt-1.5 text-sm text-fg-muted"> <p className="mt-1.5 flex flex-wrap items-center gap-x-2 gap-y-1 text-sm text-fg-muted">
{account.niche || <span className="text-fg-subtle">Sem nicho definido</span>} <span title={`Idioma e público: ${languageLabel(account.language)}`}>
<span aria-hidden="true" className="px-2 text-fg-subtle">·</span>{publishes} <Badge tone="info" dot={false}>
<span className="font-semibold">{languageShort(account.language)}</span>
<span aria-hidden="true">·</span>{languageLabel(account.language)}
</Badge>
</span>
<span>{account.niche || <span className="text-fg-subtle">Sem nicho definido</span>}</span>
<span aria-hidden="true" className="text-fg-subtle">·</span><span>{publishes}</span>
</p> </p>
</div> </div>
<div className="flex flex-wrap items-center gap-2"> <div className="flex flex-wrap items-center gap-2">
@@ -259,6 +275,13 @@ function AccountDataCard({ account, onEdit }: { account: AccountView; onEdit: ()
<dt className="text-[0.8125rem] text-fg-subtle">Nicho</dt> <dt className="text-[0.8125rem] text-fg-subtle">Nicho</dt>
<dd className="text-fg">{account.niche || <span className="text-fg-subtle">—</span>}</dd> <dd className="text-fg">{account.niche || <span className="text-fg-subtle">—</span>}</dd>
</div> </div>
<div className="grid gap-1">
<dt className="text-[0.8125rem] text-fg-subtle">Idioma e público</dt>
<dd className="text-fg">
{languageLabel(account.language)}
<span className="block text-xs text-fg-subtle">{ACCOUNT_LANGUAGES.find((l) => l.id === account.language)?.audience ?? "—"}</span>
</dd>
</div>
<div className="grid gap-1"> <div className="grid gap-1">
<dt className="text-[0.8125rem] text-fg-subtle">Criado em</dt> <dt className="text-[0.8125rem] text-fg-subtle">Criado em</dt>
<dd className="text-fg">{formatDate(account.created_at)}</dd> <dd className="text-fg">{formatDate(account.created_at)}</dd>
+1 -1
View File
@@ -308,7 +308,7 @@ export function PublishingRulesCard({ account, className }: { account: AccountVi
{ value: "best_slot", label: "No próximo horário bom", hint: "Mais gente vendo" }, { value: "best_slot", label: "No próximo horário bom", hint: "Mais gente vendo" },
]} /> ]} />
<p className="text-[0.8125rem] leading-relaxed text-fg-subtle"> <p className="text-[0.8125rem] leading-relaxed text-fg-subtle">
Os horários bons de cada rede ficam em <TextLink href="/settings">Configurações</TextLink>. Entre dois vídeos na mesma rede fica pelo menos 1 hora. Os horários bons de cada rede ficam em <TextLink href="/settings/publishing">Configurações</TextLink>. Entre dois vídeos na mesma rede fica pelo menos 1 hora.
</p> </p>
</div> </div>
+4 -4
View File
@@ -27,8 +27,8 @@ const KINDS: { id: AgentKind; label: string; description: string; icon: Componen
{ id: "free", label: "Pedido livre", description: "Ajustes no projeto, testes, iluminação", icon: ChatIcon }, { id: "free", label: "Pedido livre", description: "Ajustes no projeto, testes, iluminação", icon: ChatIcon },
]; ];
export const PROVIDER_LABEL: Record<Provider, string> = { claude: "Claude Code", codex: "GPT · Codex" }; export const PROVIDER_LABEL: Record<Provider, string> = { claude: "Claude Code", codex: "GPT · Codex", gemini: "Gemini" };
const PROVIDER_SHORT: Record<Provider, string> = { claude: "Claude", codex: "GPT" }; const PROVIDER_SHORT: Record<Provider, string> = { claude: "Claude", codex: "GPT", gemini: "Gemini" };
const PLACEHOLDER: Record<AgentKind, string> = { const PLACEHOLDER: Record<AgentKind, string> = {
story: "Ex.: Um entregador recebe um pacote sem remetente; toda vez que tenta entregar, o endereço muda. Suspense leve com humor.", story: "Ex.: Um entregador recebe um pacote sem remetente; toda vez que tenta entregar, o endereço muda. Suspense leve com humor.",
@@ -210,7 +210,7 @@ export function AgentConsole(props: {
{/* 2. Agente */} {/* 2. Agente */}
<fieldset className="grid gap-3"> <fieldset className="grid gap-3">
<legend className="mb-3 text-eyebrow font-semibold uppercase text-fg-subtle">2 · Agente</legend> <legend className="mb-3 text-eyebrow font-semibold uppercase text-fg-subtle">2 · Agente</legend>
<div className="grid gap-3 md:grid-cols-2"> <div className="grid gap-3 md:grid-cols-3">
{props.providers.map((p) => ( {props.providers.map((p) => (
<ProviderCard key={p.id} info={p} selected={provider === p.id} recommended={preferred === p.id} <ProviderCard key={p.id} info={p} selected={provider === p.id} recommended={preferred === p.id}
onSelect={() => chooseProvider(p.id)} /> onSelect={() => chooseProvider(p.id)} />
@@ -334,7 +334,7 @@ function ProviderCard({ info, selected, recommended, onSelect }:
<span className="flex flex-wrap items-center gap-2"> <span className="flex flex-wrap items-center gap-2">
<span className="text-sm font-semibold text-fg">{PROVIDER_LABEL[info.id]}</span> <span className="text-sm font-semibold text-fg">{PROVIDER_LABEL[info.id]}</span>
{recommended && <Badge tone="accent" dot={false}>padrão desta tarefa</Badge>} {recommended && <Badge tone="accent" dot={false}>padrão desta tarefa</Badge>}
{!info.available && <Badge tone="warning" dot={false}>não instalado</Badge>} {!info.available && <Badge tone="warning" dot={false}>não está pronto</Badge>}
</span> </span>
<span id={hintId} className="grid gap-1 text-xs leading-relaxed text-fg-subtle"> <span id={hintId} className="grid gap-1 text-xs leading-relaxed text-fg-subtle">
{info.version && <span className="font-mono text-[0.6875rem] text-fg-muted">{info.version}</span>} {info.version && <span className="font-mono text-[0.6875rem] text-fg-muted">{info.version}</span>}
+358
View File
@@ -0,0 +1,358 @@
"use client";
// Configurações → IA: as três CLIs (Claude Code, Codex/GPT e Gemini) num cartão cada — instalar/atualizar, ligar,
// entrar com a conta (OAuth, num terminal) ou colar a chave de API (cofre DPAPI), testar — e a IA reserva
// (troca sozinha quando uma cair, pausa e ordem). API: GET/PUT /api/ai e POST/PUT/DELETE /api/ai/[provider].
import { useCallback, useEffect, useState, type ReactNode } from "react";
import type { AiSettings, AuthMode, ProviderStatus, TestResult } from "@/lib/ai";
import type { Provider } from "@/lib/types";
import { CopyButton } from "./copy-button";
import { AlertIcon, ArrowLeftIcon, CheckIcon, CpuIcon, DownloadIcon, KeyIcon, LinkIcon, PauseIcon, PlayIcon, RefreshIcon, TrashIcon, UsersIcon } from "./icons";
import { Badge, Button, Card, ChoiceGroup, Feedback, Field, Input, Select, Spinner, Switch, cx, type Tone } from "./ui";
type Payload = { settings: AiSettings; providers: ProviderStatus[]; test?: TestResult };
type Result<T> = { ok: true; data: T } | { ok: false; error: string };
type Message = { ok: boolean; text: string } | null;
async function aiCall<T = Payload>(path: string, method = "GET", body?: unknown): Promise<Result<T>> {
try {
const response = await fetch(`/api/ai${path}`, {
method, cache: "no-store",
headers: body === undefined ? undefined : { "Content-Type": "application/json" },
body: body === undefined ? undefined : JSON.stringify(body),
});
const data = (await response.json().catch(() => ({}))) as T & { error?: string };
return response.ok ? { ok: true, data } : { ok: false, error: data.error ?? `Erro ${response.status}` };
} catch {
return { ok: false, error: "O painel não respondeu." };
}
}
const COOLDOWN_OPTIONS = [5, 15, 30, 60, 120];
const PROVIDER_TAGLINE: Record<Provider, string> = {
claude: "Cena, Godot e ajustes no projeto. Mostra o custo em US$.",
codex: "GPT: enredo e roteiro por padrão. Usa a conta do ChatGPT.",
gemini: "Google. Boa reserva com chave do AI Studio (tem cota gratuita).",
};
const time = (iso: string) => new Date(iso).toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit" });
/** Situação em uma palavra (badge do cartão e da ordem). */
function statusBadge(p: ProviderStatus): { tone: Tone; text: string } {
if (!p.settings.enabled) return { tone: "neutral", text: "desligada" };
if (!p.installed) return { tone: "warning", text: "não instalada" };
if (!p.ready) return { tone: "warning", text: p.settings.authMode === "apiKey" ? "falta a chave" : "falta entrar" };
if (p.cooldown) return { tone: "danger", text: `em pausa até ${time(p.cooldown.until)}` };
return { tone: "success", text: "pronta" };
}
export function AiSettings() {
const [data, setData] = useState<Payload | null>(null);
const [error, setError] = useState<string | null>(null);
const load = useCallback(async (refresh = false) => {
const r = await aiCall(refresh ? "?refresh=1" : "");
if (r.ok) { setData(r.data); setError(null); } else setError(r.error);
}, []);
useEffect(() => { void load(); }, [load]);
// Instalação em andamento: relê a cada 2 s para mostrar o log.
const installing = data?.providers.some((p) => p.install?.status === "running") ?? false;
useEffect(() => {
if (!installing) return;
const timer = setInterval(() => void load(), 2000);
return () => clearInterval(timer);
}, [installing, load]);
if (error && !data) {
return (
<div className="grid justify-items-start gap-3">
<Feedback ok={false}>Não deu para ler as IAs: {error}</Feedback>
<Button variant="secondary" size="sm" onClick={() => void load()}><RefreshIcon size={15} />Tentar de novo</Button>
</div>
);
}
if (!data) return <p role="status" className="flex items-center gap-2 text-sm text-fg-muted"><Spinner />Procurando as CLIs neste computador…</p>;
const readyCount = data.providers.filter((p) => p.ready).length;
const byId = Object.fromEntries(data.providers.map((p) => [p.id, p])) as Record<Provider, ProviderStatus>;
return (
<div className="grid gap-8">
{readyCount === 0 && (
<Feedback ok={false}>Nenhuma IA está pronta. Instale pelo menos uma abaixo e entre com a conta (ou cole uma chave de API).</Feedback>
)}
<FallbackCard data={data} onChange={setData} />
<section aria-labelledby="ias" className="grid gap-4">
<div className="flex flex-wrap items-end justify-between gap-3">
<div>
<h2 id="ias" className="text-base font-semibold text-fg">As IAs deste computador</h2>
<p className="mt-1 max-w-[75ch] text-sm text-fg-subtle">
Cada uma roda pela CLI oficial. <strong className="font-medium text-fg-muted">Conta</strong> usa a assinatura em que você já paga
(login no navegador); <strong className="font-medium text-fg-muted">chave de API</strong> cobra por uso e fica cifrada neste PC.
</p>
</div>
<Button variant="ghost" size="sm" onClick={() => void load(true)}><RefreshIcon size={15} />Procurar de novo</Button>
</div>
<div className="grid gap-5 xl:grid-cols-3">
{data.settings.order.map((id) => <ProviderCard key={id} status={byId[id]} onChange={setData} />)}
</div>
</section>
</div>
);
}
/* ---------- Reserva ---------- */
function FallbackCard({ data, onChange }: { data: Payload; onChange: (next: Payload) => void }) {
const { settings } = data;
const [busy, setBusy] = useState<string | null>(null);
const [message, setMessage] = useState<Message>(null);
const byId = Object.fromEntries(data.providers.map((p) => [p.id, p])) as Record<Provider, ProviderStatus>;
async function save(key: string, patch: Partial<{ order: Provider[]; fallback: Partial<AiSettings["fallback"]> }>, ok: string) {
setBusy(key);
setMessage(null);
const r = await aiCall("", "PUT", patch);
setBusy(null);
if (r.ok) { onChange(r.data); setMessage({ ok: true, text: ok }); } else setMessage({ ok: false, text: r.error });
}
function move(index: number, delta: -1 | 1) {
const order = [...settings.order];
const [item] = order.splice(index, 1);
order.splice(index + delta, 0, item);
void save(`move-${item}`, { order }, "Ordem salva.");
}
return (
<Card eyebrow={<><RefreshIcon size={13} />IA reserva</>} title="Se uma IA cair, a próxima assume"
description="Vale para os agentes do painel e para o juiz do Clipador. A tarefa começa na IA escolhida (ou na preferida dela); se falhar por limite de uso, login, chave ou rede, recomeça na próxima pronta desta lista. Erro do pedido em si não troca de IA.">
<div className="grid gap-6 lg:grid-cols-[minmax(0,1fr)_minmax(0,1.2fr)]">
<div className="grid content-start gap-5">
<Switch label="Trocar de IA sozinho" checked={settings.fallback.enabled} busy={busy === "enabled"}
hint={settings.fallback.enabled ? "Ligado: a tarefa continua na próxima IA, que confere o que a anterior já fez." : "Desligado: a tarefa para com erro e você escolhe outra IA."}
onChange={(enabled) => void save("enabled", { fallback: { enabled } }, enabled ? "Reserva ligada." : "Reserva desligada.")} />
<Field label="Depois de cair, pular a IA por" hint="Evita insistir numa IA sem cota. Dá para tirar da pausa no cartão dela.">
<Select value={settings.fallback.cooldownMin} disabled={busy === "cooldown"}
onChange={(e) => void save("cooldown", { fallback: { cooldownMin: Number(e.target.value) } }, "Pausa salva.")}>
{[...new Set([...COOLDOWN_OPTIONS, settings.fallback.cooldownMin])].sort((a, b) => a - b)
.map((m) => <option key={m} value={m}>{m < 60 ? `${m} minutos` : `${m / 60} hora${m > 60 ? "s" : ""}`}</option>)}
</Select>
</Field>
</div>
<div className="grid content-start gap-2">
<span className="text-[0.8125rem] font-medium text-fg-muted">Ordem de uso</span>
<ol className="grid gap-2">
{settings.order.map((id, index) => {
const p = byId[id];
const badge = statusBadge(p);
return (
<li key={id} className={cx("flex items-center gap-3 rounded-control border border-line bg-sunken/60 px-3 py-2", !p.ready && "opacity-70")}>
<span className="grid size-6 shrink-0 place-items-center rounded-full bg-overlay text-xs font-semibold tabular-nums text-fg-muted">{index + 1}</span>
<span className="min-w-0 flex-1 truncate text-sm font-medium text-fg">{p.label}</span>
<Badge tone={badge.tone}>{badge.text}</Badge>
<span className="flex gap-1">
<Button variant="ghost" size="sm" aria-label={`Subir ${p.label}`} disabled={index === 0 || busy !== null}
onClick={() => move(index, -1)} className="px-2"><ArrowLeftIcon size={14} className="rotate-90" /></Button>
<Button variant="ghost" size="sm" aria-label={`Descer ${p.label}`} disabled={index === settings.order.length - 1 || busy !== null}
onClick={() => move(index, 1)} className="px-2"><ArrowLeftIcon size={14} className="-rotate-90" /></Button>
</span>
</li>
);
})}
</ol>
<p className="text-xs text-fg-subtle">IA desligada ou sem login/chave é pulada.</p>
</div>
</div>
{message && <div className="mt-5"><Feedback ok={message.ok}>{message.text}</Feedback></div>}
</Card>
);
}
/* ---------- Cartão de cada IA ---------- */
function ProviderCard({ status: p, onChange }: { status: ProviderStatus; onChange: (next: Payload) => void }) {
const [busy, setBusy] = useState<string | null>(null);
const [message, setMessage] = useState<Message>(null);
const [key, setKey] = useState("");
const badge = statusBadge(p);
async function act(name: string, call: () => Promise<Result<Payload>>, ok?: (data: Payload) => string) {
setBusy(name);
setMessage(null);
const r = await call();
setBusy(null);
if (!r.ok) { setMessage({ ok: false, text: r.error }); return false; }
onChange(r.data);
if (ok) setMessage({ ok: true, text: ok(r.data) });
return true;
}
const post = (action: string) => () => aiCall(`/${p.id}`, "POST", { action });
return (
<article aria-labelledby={`ia-${p.id}`}
className={cx("grid content-start gap-5 rounded-card border border-line bg-surface p-5 shadow-card", !p.settings.enabled && "opacity-80")}>
<header className="grid gap-3">
<div className="flex items-start justify-between gap-3">
<div className="min-w-0">
<h3 id={`ia-${p.id}`} className="flex flex-wrap items-center gap-2 text-base font-semibold text-fg">
<CpuIcon size={17} />{p.label}<span className="text-xs font-normal text-fg-subtle">{p.vendor}</span>
</h3>
<p className="mt-1 text-xs leading-relaxed text-fg-subtle">{PROVIDER_TAGLINE[p.id]}</p>
</div>
<Badge tone={badge.tone}>{badge.text}</Badge>
</div>
<Switch label="Usar esta IA" checked={p.settings.enabled} busy={busy === "enabled"}
hint={p.settings.enabled ? "Pode ser escolhida e entra na reserva." : "Nunca é chamada, nem como reserva."}
onChange={(enabled) => void act("enabled", () => aiCall("", "PUT", { providers: { [p.id]: { enabled } } }))} />
</header>
<InstallSection p={p} busy={busy} onInstall={() => void act("install", post("install"))} />
{p.installed && (
<section className="grid gap-3 border-t border-line pt-4" aria-label={`Como o ${p.label} entra`}>
<ChoiceGroup<AuthMode> name={`auth-${p.id}`} legend="Como entra" value={p.settings.authMode}
onChange={(authMode) => void act("auth", () => aiCall("", "PUT", { providers: { [p.id]: { authMode } } }))}
options={[
{ value: "oauth", label: <span className="inline-flex items-center gap-1.5"><UsersIcon size={14} />Conta</span> },
{ value: "apiKey", label: <span className="inline-flex items-center gap-1.5"><KeyIcon size={14} />Chave de API</span> },
]} />
{p.settings.authMode === "oauth"
? <OAuthSection p={p} busy={busy}
onLogin={() => void act("login", post("login"), () => "Abrimos um terminal com o login. Termine no navegador e clique em Verificar.")}
onVerify={() => void act("verify", post("verify"), (d) => d.providers.find((x) => x.id === p.id)?.oauth.detail || "Verificado.")} />
: <ApiKeySection p={p} busy={busy} value={key} onValue={setKey}
onSave={() => void act("key", () => aiCall(`/${p.id}`, "PUT", { apiKey: key }), () => "Chave salva no cofre deste PC.").then((ok) => ok && setKey(""))}
onRemove={() => void act("remove", () => aiCall(`/${p.id}`, "DELETE"), () => "Chave apagada.")} />}
</section>
)}
{p.installed && p.settings.enabled && (
<footer className="grid gap-3 border-t border-line pt-4">
{p.cooldown && (
<div className="flex flex-wrap items-center gap-2 rounded-control border border-danger/30 bg-danger-soft/50 px-3 py-2 text-xs text-danger">
<PauseIcon size={14} /><span className="min-w-0 flex-1">Em pausa até {time(p.cooldown.until)}: {p.cooldown.reason}</span>
<Button variant="ghost" size="sm" disabled={busy !== null} onClick={() => void act("resume", post("resume"), () => "Saiu da pausa.")}>
<PlayIcon size={14} />Tirar da pausa
</Button>
</div>
)}
<div className="flex flex-wrap items-center gap-3">
<Button variant="secondary" size="sm" disabled={busy !== null || !p.ready}
onClick={() => void act("test", post("test"))}>
{busy === "test" ? <><Spinner className="size-3.5" />Testando…</> : <><CheckIcon size={15} />Testar</>}
</Button>
<span className="text-xs text-fg-subtle">Faz uma pergunta mínima (poucos tokens) fora do projeto.</span>
</div>
{p.lastTest && (
<p className={cx("text-xs", p.lastTest.ok ? "text-success" : "text-danger")} role="status">
{p.lastTest.ok ? "Funcionou" : "Falhou"} às {time(p.lastTest.at)} · {(p.lastTest.ms / 1000).toFixed(1)} s · {p.lastTest.text}
</p>
)}
</footer>
)}
{message && <Feedback ok={message.ok}>{message.text}</Feedback>}
</article>
);
}
function InstallSection({ p, busy, onInstall }: { p: ProviderStatus; busy: string | null; onInstall: () => void }) {
const job = p.install;
const running = job?.status === "running";
return (
<section className="grid gap-3 border-t border-line pt-4" aria-label={`Instalação do ${p.label}`}>
{p.installed ? (
<div className="flex flex-wrap items-center justify-between gap-2">
<div className="grid min-w-0 gap-0.5">
<span className="flex items-center gap-1.5 text-sm text-fg"><CheckIcon size={14} className="text-success" />Instalada</span>
<span className="truncate font-mono text-[0.6875rem] text-fg-subtle" title={p.path ?? undefined}>{p.version}</span>
</div>
<Button variant="ghost" size="sm" disabled={running || busy !== null} onClick={onInstall}>
{running ? <><Spinner className="size-3.5" />Atualizando…</> : <><DownloadIcon size={14} />Atualizar</>}
</Button>
</div>
) : (
<div className="grid gap-3">
<p className="text-sm text-fg-muted">A CLI não foi encontrada neste computador.</p>
<div className="flex items-center gap-2 rounded-control border border-line bg-sunken px-3 py-2">
<code className="min-w-0 flex-1 truncate font-mono text-xs text-fg-muted">{p.meta.installCommand}</code>
<CopyButton text={p.meta.installCommand} label="Copiar comando" variant="ghost" size="sm" />
</div>
<Button variant="flame" size="sm" className="justify-self-start" disabled={running || busy !== null} onClick={onInstall}>
{running ? <><Spinner className="size-3.5" />Instalando…</> : <><DownloadIcon size={15} />Instalar {p.label}</>}
</Button>
</div>
)}
{job && (job.status !== "success" || !p.installed) && (
<details open={job.status !== "success"} className="rounded-control border border-line bg-sunken">
<summary className="cursor-pointer px-3 py-2 text-xs text-fg-muted">
{job.status === "running" ? "Instalando…" : job.status === "success" ? "Instalação concluída" : "A instalação falhou"} · log
</summary>
<pre className="max-h-48 overflow-auto px-3 pb-3 font-mono text-[0.6875rem] leading-relaxed whitespace-pre-wrap text-fg-subtle">{job.log.slice(-40).join("\n")}</pre>
</details>
)}
{job?.status === "success" && !p.installed && (
<Feedback ok={false}>Instalou, mas o painel ainda não acha a CLI (o PATH dele é o de quando abriu). Clique em &quot;Procurar de novo&quot; ou reinicie o <code>pnpm panel</code>.</Feedback>
)}
</section>
);
}
function OAuthSection({ p, busy, onLogin, onVerify }: { p: ProviderStatus; busy: string | null; onLogin: () => void; onVerify: () => void }) {
const tone = p.oauth.state === "yes" ? "text-success" : p.oauth.state === "no" ? "text-warning" : "text-fg-muted";
return (
<div className="grid gap-3">
<p className="text-xs text-fg-subtle">{p.meta.oauthLabel}. O login é feito pela própria CLI: o painel nunca vê a senha.</p>
{p.oauth.detail && <p className={cx("text-sm", tone)}>{p.oauth.detail}</p>}
{p.meta.oauthNote && (
<p className="flex gap-2 rounded-control border border-warning/30 bg-warning-soft/40 px-3 py-2 text-xs leading-relaxed text-warning">
<AlertIcon size={14} className="mt-0.5 shrink-0" />{p.meta.oauthNote}
</p>
)}
<div className="flex flex-wrap gap-2">
{p.meta.canLogin && (
<Button variant={p.oauth.state === "yes" ? "ghost" : "primary"} size="sm" disabled={busy !== null} onClick={onLogin}>
{busy === "login" ? <Spinner className="size-3.5" /> : <LinkIcon size={14} />}{p.oauth.state === "yes" ? "Trocar de conta" : "Entrar com a conta"}
</Button>
)}
<Button variant="secondary" size="sm" disabled={busy !== null} onClick={onVerify}>
{busy === "verify" ? <Spinner className="size-3.5" /> : <RefreshIcon size={14} />}Verificar
</Button>
</div>
</div>
);
}
function ApiKeySection({ p, busy, value, onValue, onSave, onRemove }: {
p: ProviderStatus; busy: string | null; value: string; onValue: (v: string) => void; onSave: () => void; onRemove: () => void;
}) {
return (
<form className="grid gap-3" onSubmit={(e) => { e.preventDefault(); onSave(); }}>
{p.apiKey.saved && (
<div className="flex flex-wrap items-center justify-between gap-2 text-sm">
<span className="flex items-center gap-1.5 text-success"><KeyIcon size={14} />Chave salva <span className="font-mono text-xs text-fg-subtle">{p.apiKey.hint}</span></span>
<Button type="button" variant="ghost" size="sm" disabled={busy !== null} onClick={onRemove}><TrashIcon size={14} />Apagar</Button>
</div>
)}
<Field label={p.apiKey.saved ? "Trocar a chave" : p.meta.apiKeyLabel}
hint={<>Fica cifrada neste PC (DPAPI do Windows) e nunca volta para a tela. Vai para a CLI como <code>{p.meta.apiKeyEnv}</code> só na hora da chamada.</>}>
<Input type="password" autoComplete="off" spellCheck={false} value={value} onChange={(e) => onValue(e.target.value)} placeholder="Cole a chave aqui" />
</Field>
<div className="flex flex-wrap items-center gap-3">
<Button type="submit" size="sm" disabled={busy !== null || value.trim().length < 16}>
{busy === "key" ? <Spinner className="size-3.5" /> : <KeyIcon size={14} />}Salvar chave
</Button>
<ExternalLink href={p.meta.apiKeyUrl}>Criar uma chave</ExternalLink>
</div>
</form>
);
}
function ExternalLink({ href, children }: { href: string; children: ReactNode }) {
return (
<a href={href} target="_blank" rel="noreferrer" className="inline-flex items-center gap-1 text-xs text-fg-muted underline underline-offset-2 hover:text-fg">
{children}<LinkIcon size={12} />
</a>
);
}
+74 -6
View File
@@ -4,10 +4,11 @@
// escolhe daqui (montagem Cartoon). // escolhe daqui (montagem Cartoon).
import { useEffect, useState } from "react"; import { useEffect, useState } from "react";
import { import {
BEARD_STYLES, BOTTOM_STYLES, BROWS, BUILDS, EXPRESSIONS, GLASSES, HAIR_STYLES, POSES, TOP_STYLES, ACCESSORIES, BEARD_STYLES, BOTTOM_STYLES, BROWS, BUILDS, EXPRESSIONS, FOOTWEAR, GLASSES, HAIR_STYLES, HEAD_SHAPES, NOSES, POSES, TOP_STYLES,
type Character, type CharacterLook, type Expression, type Pose, type Character, type CharacterLook, type Expression, type Pose,
} from "cenaforge-cartoon/character"; } from "cenaforge-cartoon/character";
import { CharacterFigure } from "cenaforge-cartoon/figure"; import { CharacterFigure } from "cenaforge-cartoon/figure";
import { ACTIONS, evaluate, type ActionKind } from "cenaforge-cartoon/motion";
import { apiCall } from "./api-client"; import { apiCall } from "./api-client";
import { askConfirm } from "./confirm-dialog"; import { askConfirm } from "./confirm-dialog";
import { PlusIcon, SparkIcon, TrashIcon, UsersIcon } from "./icons"; import { PlusIcon, SparkIcon, TrashIcon, UsersIcon } from "./icons";
@@ -18,10 +19,20 @@ const LABEL: Record<string, string> = {
short: "curto", side: "repartido", bun: "coque", long: "longo", curly: "cacheado", spiky: "espetado", bald: "careca", cap: "boné", short: "curto", side: "repartido", bun: "coque", long: "longo", curly: "cacheado", spiky: "espetado", bald: "careca", cap: "boné",
none: "nenhum", stubble: "por fazer", mustache: "bigode", full: "cheia", goatee: "cavanhaque", none: "nenhum", stubble: "por fazer", mustache: "bigode", full: "cheia", goatee: "cavanhaque",
round: "redondo", square: "quadrado", sun: "escuro", thin: "finas", thick: "grossas", round: "redondo", square: "quadrado", sun: "escuro", thin: "finas", thick: "grossas",
shirt: "camisa", jacket: "jaqueta", hoodie: "moletom", dress: "vestido", uniform: "uniforme", shirt: "camisa", jacket: "jaqueta", hoodie: "moletom", dress: "vestido", uniform: "uniforme", robe: "túnica",
shoes: "sapato", sandals: "sandália", bare: "descalço",
pants: "calça", shorts: "bermuda", skirt: "saia", pants: "calça", shorts: "bermuda", skirt: "saia",
neutral: "neutro", happy: "feliz", sad: "triste", worried: "preocupado", angry: "bravo", surprised: "surpreso", scared: "com medo", neutral: "neutro", smile: "sorriso", happy: "feliz", laugh: "rindo", proud: "orgulhoso", sad: "triste", cry: "chorando", worried: "preocupado",
stand: "em pé", point: "apontando", wave: "acenando", hold: "segurando", arms_up: "braços pra cima", shrug: "ombros", think: "pensando", angry: "bravo", furious: "furioso", surprised: "surpreso", scared: "com medo", shocked: "chocado", suspicious: "desconfiado", smirk: "sorriso de canto",
confused: "confuso", disgusted: "enojado", sleepy: "com sono", determined: "decidido", embarrassed: "envergonhado",
stand: "em pé", point: "apontando", wave: "acenando", hold: "segurando", arms_up: "braços pra cima", celebrate: "comemorando", shrug: "ombros",
think: "pensando", hands_on_hips: "mãos na cintura", cross_arms: "braços cruzados", facepalm: "mão na testa", cover_mouth: "mão na boca",
defend: "se defendendo", reach: "alcançando", sit: "sentado", kneel: "ajoelhado", lean_in: "inclinado",
express: "trocar expressão", pose: "trocar pose", walk: "andar", run: "correr", enter: "entrar", exit: "sair", jump: "pular", nod: "acenar que sim",
shake_head: "balançar que não", tremble: "tremer", bounce: "quicar", fall: "cair", stand_up: "levantar", turn: "virar", talk: "falar", look: "olhar",
emote: "balão (!)", hammer: "martelar",
oval: "oval", wide: "largo", button: "botão", curve: "curvo (perfil)", towel: "toalha no ombro", whistle: "apito", tie: "gravata",
vest: "colete refletivo", helmet: "capacete", watch: "relógio", badge: "crachá", apron: "avental", scarf: "lenço", headset: "fone", chain: "corrente",
}; };
const label = (v: string) => LABEL[v] ?? v; const label = (v: string) => LABEL[v] ?? v;
@@ -56,6 +67,8 @@ export function CharacterStudio({ initial }: { initial: Character[] }) {
const [draft, setDraft] = useState<Character | null>(initial[0] ?? null); const [draft, setDraft] = useState<Character | null>(initial[0] ?? null);
const [expression, setExpression] = useState<Expression>("neutral"); const [expression, setExpression] = useState<Expression>("neutral");
const [pose, setPose] = useState<Pose>("stand"); const [pose, setPose] = useState<Pose>("stand");
// Movimento da prévia: a ação toca em repetição a cada 2,6 s (o mesmo motor do render).
const [move, setMove] = useState<ActionKind | "">("");
const [t, setT] = useState(0); const [t, setT] = useState(0);
const [busy, setBusy] = useState<string | null>(null); const [busy, setBusy] = useState<string | null>(null);
const [message, setMessage] = useState<{ ok: boolean; text: React.ReactNode } | null>(null); const [message, setMessage] = useState<{ ok: boolean; text: React.ReactNode } | null>(null);
@@ -175,10 +188,16 @@ export function CharacterStudio({ initial }: { initial: Character[] }) {
<div className="grid gap-5 xl:grid-cols-[minmax(0,18rem)_minmax(0,1fr)]"> <div className="grid gap-5 xl:grid-cols-[minmax(0,18rem)_minmax(0,1fr)]">
<div className="grid content-start gap-3"> <div className="grid content-start gap-3">
<div className="grid place-items-center rounded-lg border border-line-strong bg-[#2a2e45] p-4"> <div className="grid place-items-center rounded-lg border border-line-strong bg-[#2a2e45] p-4">
<div className="h-80 w-36"><CharacterFigure look={look} expression={expression} pose={pose} item={pose === "hold" || pose === "point" ? "phone" : undefined} t={t} /></div> <MovePreview look={look} expression={expression} pose={pose} move={move} t={t} />
</div> </div>
<Opt name="Expressão (prévia)" list={EXPRESSIONS} value={expression} onChange={setExpression} /> <Opt name="Expressão (prévia)" list={EXPRESSIONS} value={expression} onChange={setExpression} />
<Opt name="Pose (prévia)" list={POSES} value={pose} onChange={setPose} /> <Opt name="Pose (prévia)" list={POSES} value={pose} onChange={setPose} />
<Field label="Movimento (prévia)">
<Select value={move} onChange={(e) => setMove(e.target.value as ActionKind | "")}>
<option value="">parado (só respira e pisca)</option>
{ACTIONS.filter((a) => !["express", "pose", "enter", "exit"].includes(a)).map((a) => <option key={a} value={a}>{label(a)}</option>)}
</Select>
</Field>
</div> </div>
<div className="grid content-start gap-4"> <div className="grid content-start gap-4">
<div className="grid gap-3 sm:grid-cols-2"> <div className="grid gap-3 sm:grid-cols-2">
@@ -193,7 +212,8 @@ export function CharacterStudio({ initial }: { initial: Character[] }) {
onChange={(e) => setLook((l) => ({ ...l, height: Number(e.target.value) }))} /> onChange={(e) => setLook((l) => ({ ...l, height: Number(e.target.value) }))} />
</Field> </Field>
<Color name="Pele" value={look.skin} onChange={(v) => setLook((l) => ({ ...l, skin: v }))} /> <Color name="Pele" value={look.skin} onChange={(v) => setLook((l) => ({ ...l, skin: v }))} />
<Color name="Sapato" value={look.shoes} onChange={(v) => setLook((l) => ({ ...l, shoes: v }))} /> <Opt name="Calçado" list={FOOTWEAR} value={look.footwear ?? "shoes"} onChange={(v) => setLook((l) => ({ ...l, footwear: v }))} />
<Color name="Cor do calçado" value={look.shoes} onChange={(v) => setLook((l) => ({ ...l, shoes: v }))} />
<Opt name="Cabelo" list={HAIR_STYLES} value={look.hair.style} onChange={(v) => setLook((l) => ({ ...l, hair: { ...l.hair, style: v } }))} /> <Opt name="Cabelo" list={HAIR_STYLES} value={look.hair.style} onChange={(v) => setLook((l) => ({ ...l, hair: { ...l.hair, style: v } }))} />
<Color name="Cor do cabelo" value={look.hair.color} onChange={(v) => setLook((l) => ({ ...l, hair: { ...l.hair, color: v } }))} /> <Color name="Cor do cabelo" value={look.hair.color} onChange={(v) => setLook((l) => ({ ...l, hair: { ...l.hair, color: v } }))} />
<Opt name="Barba" list={BEARD_STYLES} value={look.beard.style} onChange={(v) => setLook((l) => ({ ...l, beard: { ...l.beard, style: v } }))} /> <Opt name="Barba" list={BEARD_STYLES} value={look.beard.style} onChange={(v) => setLook((l) => ({ ...l, beard: { ...l.beard, style: v } }))} />
@@ -205,6 +225,37 @@ export function CharacterStudio({ initial }: { initial: Character[] }) {
<Color name="Detalhe (faixa/gola)" value={look.top.accent ?? "#e8b13a"} onChange={(v) => setLook((l) => ({ ...l, top: { ...l.top, accent: v } }))} /> <Color name="Detalhe (faixa/gola)" value={look.top.accent ?? "#e8b13a"} onChange={(v) => setLook((l) => ({ ...l, top: { ...l.top, accent: v } }))} />
<Opt name="Parte de baixo" list={BOTTOM_STYLES} value={look.bottom.style} onChange={(v) => setLook((l) => ({ ...l, bottom: { ...l.bottom, style: v } }))} /> <Opt name="Parte de baixo" list={BOTTOM_STYLES} value={look.bottom.style} onChange={(v) => setLook((l) => ({ ...l, bottom: { ...l.bottom, style: v } }))} />
<Color name="Cor de baixo" value={look.bottom.color} onChange={(v) => setLook((l) => ({ ...l, bottom: { ...l.bottom, color: v } }))} /> <Color name="Cor de baixo" value={look.bottom.color} onChange={(v) => setLook((l) => ({ ...l, bottom: { ...l.bottom, color: v } }))} />
<Opt name="Cabeça" list={HEAD_SHAPES} value={look.head ?? "round"} onChange={(v) => setLook((l) => ({ ...l, head: v }))} />
<Opt name="Nariz" list={NOSES} value={look.nose ?? "button"} onChange={(v) => setLook((l) => ({ ...l, nose: v }))} />
<Field label={`Pálpebra (${(look.lids ?? 0).toFixed(2)})`} hint="Olhar caído/experiente">
<input type="range" min={0} max={0.6} step={0.02} value={look.lids ?? 0} className="h-9 w-full accent-accent"
onChange={(e) => setLook((l) => ({ ...l, lids: Number(e.target.value) }))} />
</Field>
<Field label={`Rugas (${(look.wrinkles ?? 0).toFixed(1)})`}>
<input type="range" min={0} max={1} step={0.1} value={look.wrinkles ?? 0} className="h-9 w-full accent-accent"
onChange={(e) => setLook((l) => ({ ...l, wrinkles: Number(e.target.value) }))} />
</Field>
<label className="flex items-center gap-2 self-end pb-2 text-[0.8125rem] text-fg-muted">
<input type="checkbox" className="size-4 accent-accent" checked={!!look.belly} onChange={(e) => setLook((l) => ({ ...l, belly: e.target.checked }))} />
Barriga
</label>
<Color name="Cor dos acessórios" value={look.accessoryColor ?? "#efe6d2"} onChange={(v) => setLook((l) => ({ ...l, accessoryColor: v }))} />
</div>
<div className="grid gap-1.5">
<span className="text-[0.8125rem] font-medium text-fg-muted">Acessórios</span>
<div className="flex flex-wrap gap-1.5">
{ACCESSORIES.map((a) => {
const on = look.accessories?.includes(a) ?? false;
return (
<button key={a} type="button" aria-pressed={on}
onClick={() => setLook((l) => ({ ...l, accessories: on ? (l.accessories ?? []).filter((x) => x !== a) : [...(l.accessories ?? []), a] }))}
className={cx("h-8 rounded-full border px-3 text-xs font-medium transition-colors",
on ? "border-accent/60 bg-accent-soft text-accent" : "border-line-strong bg-raised text-fg-muted hover:text-fg")}>
{label(a)}
</button>
);
})}
</div>
</div> </div>
<div className="flex flex-wrap items-center gap-2"> <div className="flex flex-wrap items-center gap-2">
<Button onClick={() => void save()} disabled={busy !== null || !dirty}>{busy === "save" ? <><Spinner />Salvando…</> : "Salvar"}</Button> <Button onClick={() => void save()} disabled={busy !== null || !dirty}>{busy === "save" ? <><Spinner />Salvando…</> : "Salvar"}</Button>
@@ -230,3 +281,20 @@ export function CharacterStudio({ initial }: { initial: Character[] }) {
</div> </div>
); );
} }
/** Prévia com movimento: aplica a ação escolhida em repetição, com posição, giro e espelho como no render. */
function MovePreview({ look, expression, pose, move, t }: { look: CharacterLook; expression: Expression; pose: Pose; move: ActionKind | ""; t: number }) {
const loop = 2.6;
const lt = t % loop;
const timeline = move
? [move === "walk" || move === "run" ? { do: move, at: 0.3, to: 0.62 } : move === "talk" ? { do: move, at: 0.3, dur: 1.8, text: "olha só que coisa interessante aconteceu" } : move === "emote" ? { do: move, at: 0.3, text: "!" } : move === "look" ? { do: move, at: 0.3, dir: "left" as const } : { do: move, at: 0.3 }]
: [];
const st = evaluate({ x: 0.5, expression, pose, timeline: timeline as never }, move ? lt : t, loop, 1);
return (
<div className="relative h-80 w-full overflow-hidden">
<div className="absolute bottom-0 h-full w-36" style={{ left: `calc(${(st.x + st.dx) * 100}% - 4.5rem)`, transform: `translateY(${st.dy * 100}%) rotate(${st.rot}deg) scale(${(st.flip ? -1 : 1) * st.sx}, ${st.sy})`, transformOrigin: "50% 100%" }}>
<CharacterFigure look={look} item={pose === "hold" || pose === "point" ? "phone" : undefined} t={t} state={st} />
</div>
</div>
);
}
+19 -3
View File
@@ -6,11 +6,12 @@
// Título e legenda são os do cartão (salvos). Cada rede mostra por que não pode ser escolhida, quando for o caso. // Título e legenda são os do cartão (salvos). Cada rede mostra por que não pode ser escolhida, quando for o caso.
import { useEffect, useState } from "react"; import { useEffect, useState } from "react";
import type { AccountView } from "@/lib/accounts"; import type { AccountView } from "@/lib/accounts";
import { DEFAULT_LANGUAGE, languageLabel, languageShort } from "@/lib/languages";
import type { Platform } from "@/lib/types"; import type { Platform } from "@/lib/types";
import { apiCall } from "./api-client"; import { apiCall } from "./api-client";
import type { Clip } from "./clipper-client"; import type { Clip } from "./clipper-client";
import { Dialog } from "./dialog"; import { Dialog } from "./dialog";
import { AlertIcon, CheckIcon, ClockIcon, PublishIcon } from "./icons"; import { AlertIcon, CheckIcon, ClockIcon, InfoIcon, PublishIcon } from "./icons";
import { PLATFORM_META } from "./platforms"; import { PLATFORM_META } from "./platforms";
import { formatTime, publishClip, toLocalInput, type ClipTiming, type PublishJob } from "./publishing-client"; import { formatTime, publishClip, toLocalInput, type ClipTiming, type PublishJob } from "./publishing-client";
import { TextLink } from "./publishing-ui"; import { TextLink } from "./publishing-ui";
@@ -98,6 +99,9 @@ function PublishDialog({ clip, jobs, onClose, onDone }: {
const [error, setError] = useState<string | null>(null); const [error, setError] = useState<string | null>(null);
const account = accounts?.find((a) => a.id === accountId) ?? null; const account = accounts?.find((a) => a.id === accountId) ?? null;
// Idioma do corte: o da sessão de origem (o serviço antigo não manda `language`; sem ele, português).
const clipLanguage = clip.language || DEFAULT_LANGUAGE;
const languageMismatch = account !== null && (account.language || DEFAULT_LANGUAGE) !== clipLanguage;
/** Redes do canal: escolhível? por quê não? (a ordem é sempre YouTube, TikTok, Instagram) */ /** Redes do canal: escolhível? por quê não? (a ordem é sempre YouTube, TikTok, Instagram) */
// `pending`: o corte já tem horário nesta rede. No "próximo horário bom" ela fica travada (o servidor não // `pending`: o corte já tem horário nesta rede. No "próximo horário bom" ela fica travada (o servidor não
@@ -223,11 +227,23 @@ function PublishDialog({ clip, jobs, onClose, onDone }: {
{accounts.length > 1 ? ( {accounts.length > 1 ? (
<Field label="Canal de publicação"> <Field label="Canal de publicação">
<Select value={accountId} onChange={(e) => pickAccount(accounts.find((a) => a.id === e.target.value) ?? null)}> <Select value={accountId} onChange={(e) => pickAccount(accounts.find((a) => a.id === e.target.value) ?? null)}>
{accounts.map((a) => <option key={a.id} value={a.id}>{a.name}</option>)} {accounts.map((a) => <option key={a.id} value={a.id}>{a.name} · {languageShort(a.language || DEFAULT_LANGUAGE)}</option>)}
</Select> </Select>
</Field> </Field>
) : ( ) : (
<p className="text-[0.8125rem] text-fg-muted">Canal de publicação: <span className="font-medium text-fg">{account?.name}</span></p> <p className="text-[0.8125rem] text-fg-muted">
Canal de publicação: <span className="font-medium text-fg">{account?.name}</span>
{account && <span className="text-fg-subtle"> · {languageLabel(account.language || DEFAULT_LANGUAGE)}</span>}
</p>
)}
{languageMismatch && account && (
<p role="note" className="flex gap-2 rounded-control border border-info/30 bg-info-soft px-3 py-2 text-[0.8125rem] leading-relaxed text-info">
<InfoIcon size={15} className="mt-0.5 shrink-0" />
<span>
Este canal publica em <span className="font-medium">{languageLabel(account.language)}</span>. O corte está em{" "}
{languageLabel(clipLanguage).toLowerCase()}: a versão traduzida vem na próxima etapa; publique só se for intencional.
</span>
</p>
)} )}
<fieldset className="grid gap-2"> <fieldset className="grid gap-2">
+235 -93
View File
@@ -1,22 +1,90 @@
"use client"; "use client";
// Canais do Clipador: cadastrar pelo link do canal, ligar o monitor (grava sozinho quando entra ao // Fontes do Clipador (/clipper/sources): os streamers de onde saem os cortes, em tabela — ao vivo/offline, monitor
// vivo), marcar se o streamer autorizou os cortes, checar agora, renomear e remover. // (ligado · pausado · desligado), autorização, idioma da live, canais de publicação ligados e as ações da fonte.
// "Adicionar fonte" abre um diálogo. Os dados vêm do ClipperProvider; cada ação recarrega tudo.
//
// Monitor pausado: parar uma gravação à mão pausa o monitor da fonte (`monitorPausedAt`, com a sessão que motivou)
// até você religar — PATCH {monitor: true} limpa a pausa. O serviço antigo não manda esses campos (nem `language`).
import Link from "next/link"; import Link from "next/link";
import { useState, type FormEvent } from "react"; import { useId, useState, type FormEvent, type ReactNode } from "react";
import { PLATFORM_LABEL, clipperCall, useClipperAction, type ClipperChannel, type ClipperSession } from "./clipper-client"; import {
LANGUAGES, PLATFORM_LABEL, clipperCall, languageLabel, useClipperAction,
type ClipperChannel, type ClipperSession,
} from "./clipper-client";
import { CutSettingsDialog, type CutScope } from "./clipper-cut-settings";
import { ChannelEmotes } from "./clipper-games"; import { ChannelEmotes } from "./clipper-games";
import { useClipper, useClipperData } from "./clipper-provider";
import { PlatformIcon } from "./clipper-sessions"; import { PlatformIcon } from "./clipper-sessions";
import { AlertIcon, BroadcastIcon, CheckIcon, PenIcon, PlusIcon, RefreshIcon, SettingsIcon, TrashIcon, UsersIcon } from "./icons";
import { Badge, Button, Card, EmptyState, Feedback, Field, Input, Spinner, Switch, formatRelative } from "./ui";
import { askConfirm } from "./confirm-dialog"; import { askConfirm } from "./confirm-dialog";
import { Dialog } from "./dialog";
import { AlertIcon, BroadcastIcon, ChatIcon, ChevronDownIcon, PenIcon, PlusIcon, RefreshIcon, SettingsIcon, TrashIcon, UsersIcon } from "./icons";
import {
Badge, Button, EmptyState, Feedback, Field, Input, Select, Spinner, Switch, Table, THead, Td, Th, cx, formatRelative,
} from "./ui";
/** Canais de publicação ligados a cada fonte (id da fonte → canais), calculado no servidor do painel. */
export type ChannelAccounts = Record<string, { id: string; name: string }[]>; export type ChannelAccounts = Record<string, { id: string; name: string }[]>;
export function ChannelAddForm({ onChanged, disabled }: { onChanged: () => void; disabled: boolean }) { /* ---------- Página ---------- */
export function SourcesPage() {
const { channelAccounts, reload, games } = useClipper();
const { status, channels, sessions } = useClipperData();
const [adding, setAdding] = useState(false);
const [cutScope, setCutScope] = useState<CutScope | null>(null);
const titleId = useId();
return (
<section aria-labelledby={titleId} className="grid gap-4">
<div className="flex flex-wrap items-end justify-between gap-x-6 gap-y-3">
<div className="grid gap-1">
<h2 id={titleId} className="text-title text-fg">Fontes</h2>
<p className="max-w-[90ch] text-xs leading-relaxed text-fg-subtle">
Monitorar grava sozinho quando a fonte entra ao vivo. Parar uma gravação à mão pausa o monitor dessa fonte até você religar;
se a live cair sozinha, a gravação é retomada na mesma sessão.
</p>
</div>
<Button onClick={() => setAdding(true)}><PlusIcon size={16} />Adicionar fonte</Button>
</div>
{channels.length === 0 ? (
<EmptyState compact icon={<BroadcastIcon size={18} />} title="Nenhuma fonte cadastrada"
action={<Button variant="secondary" onClick={() => setAdding(true)}><PlusIcon size={16} />Adicionar fonte</Button>}>
Cadastre o link do canal de um streamer. Com o monitor ligado, o Clipador grava sozinho sempre que ele entrar ao vivo.
</EmptyState>
) : (
<Table>
<THead>
<Th>Fonte</Th><Th>Ao vivo</Th><Th>Monitor</Th><Th>Autorização</Th><Th>Idioma</Th><Th>Publica em</Th><Th className="text-right">Ações</Th>
</THead>
<tbody>
{channels.map((c) => (
<SourceRow key={c.id} channel={c} accounts={channelAccounts[c.id] ?? []} showEmotes={games !== null} onChanged={reload}
onConfigure={() => setCutScope({
kind: "channel", channel: c,
// Sessões vêm da mais nova para a mais antiga: a primeira da fonte dá o quadro de referência.
session: sessions.find((s) => s.channelId === c.id) ?? null,
})} />
))}
</tbody>
</Table>
)}
<AddSourceDialog open={adding} defaultLanguage={status.settings.language} onClose={() => setAdding(false)} onChanged={reload} />
<CutSettingsDialog scope={cutScope} onClose={() => setCutScope(null)} onSaved={reload} />
</section>
);
}
/* ---------- Adicionar fonte ---------- */
function AddSourceDialog({ open, defaultLanguage, onClose, onChanged }: {
open: boolean; defaultLanguage: string; onClose: () => void; onChanged: () => void;
}) {
const { pending, message, run } = useClipperAction(onChanged); const { pending, message, run } = useClipperAction(onChanged);
const [monitor, setMonitor] = useState(true); const [monitor, setMonitor] = useState(true);
const [authorized, setAuthorized] = useState(false); const [authorized, setAuthorized] = useState(false);
const [formKey, setFormKey] = useState(0); const formId = useId();
async function submit(e: FormEvent<HTMLFormElement>) { async function submit(e: FormEvent<HTMLFormElement>) {
e.preventDefault(); e.preventDefault();
@@ -24,70 +92,60 @@ export function ChannelAddForm({ onChanged, disabled }: { onChanged: () => void;
const displayName = String(form.get("displayName") ?? "").trim(); const displayName = String(form.get("displayName") ?? "").trim();
const done = await run("add", () => clipperCall<ClipperChannel>("channels", "POST", { const done = await run("add", () => clipperCall<ClipperChannel>("channels", "POST", {
url: String(form.get("url") ?? "").trim(), ...(displayName ? { displayName } : {}), monitor, authorized, url: String(form.get("url") ?? "").trim(), ...(displayName ? { displayName } : {}), monitor, authorized,
language: String(form.get("language") ?? defaultLanguage),
}), (c) => `Fonte “${c.displayName || c.channel}” adicionada${c.monitor ? " e monitorada" : ""}.`); }), (c) => `Fonte “${c.displayName || c.channel}” adicionada${c.monitor ? " e monitorada" : ""}.`);
if (done) { setFormKey((k) => k + 1); setAuthorized(false); } if (done) onClose();
} }
return ( return (
<Card eyebrow={<><PlusIcon size={13} />Nova fonte</>} title="Adicionar fonte" <Dialog open={open} onClose={onClose} eyebrow={<><PlusIcon size={13} />Nova fonte</>} title="Adicionar fonte"
description="Link do perfil do streamer (não de um vídeo): twitch.tv/nome, kick.com/nome ou youtube.com/@nome."> description="Link do perfil do streamer (não de um vídeo): twitch.tv/nome, kick.com/nome ou youtube.com/@nome."
<form key={formKey} onSubmit={submit} className="grid gap-4"> footer={<>
<div className="grid gap-4 md:grid-cols-[minmax(0,2fr)_minmax(0,1fr)]"> <Button type="button" variant="ghost" onClick={onClose}>Cancelar</Button>
<Field label="Link da fonte"> <Button type="submit" form={formId} disabled={pending !== null}>{pending === "add" ? <><Spinner />Adicionando…</> : <><PlusIcon size={16} />Adicionar fonte</>}</Button>
<Input name="url" type="url" required disabled={disabled} placeholder="https://www.twitch.tv/nome" /> </>}>
</Field> <form id={formId} onSubmit={submit} className="grid gap-4">
<Field label="Nome para mostrar (opcional)"> <Field label="Link da fonte"><Input name="url" type="url" required autoFocus placeholder="https://www.twitch.tv/nome" /></Field>
<Input name="displayName" maxLength={60} disabled={disabled} placeholder="Ex.: Alanzoka" /> <div className="grid gap-4 sm:grid-cols-2">
<Field label="Nome para mostrar (opcional)"><Input name="displayName" maxLength={60} placeholder="Ex.: Alanzoka" /></Field>
<Field label="Idioma da live" hint="Usado na transcrição e nos textos da IA. Canais em outro idioma são configurados em Canais de publicação.">
<Select name="language" defaultValue={defaultLanguage}>
{languageOptions(defaultLanguage).map((l) => <option key={l.id} value={l.id}>{l.label}</option>)}
</Select>
</Field> </Field>
</div> </div>
<div className="grid gap-4 md:grid-cols-2"> <Switch label="Monitorar" checked={monitor} onChange={setMonitor} hint="Checa de minuto em minuto e grava sozinho quando a fonte entra ao vivo." />
<Switch label="Monitorar" checked={monitor} onChange={setMonitor} disabled={disabled} <Switch label="O streamer autorizou cortes" checked={authorized} onChange={setAuthorized}
hint="Checa de minuto em minuto e grava sozinho quando a fonte entra ao vivo." />
<Switch label="O streamer autorizou cortes" checked={authorized} onChange={setAuthorized} disabled={disabled}
hint="Cortar live de terceiros sem autorização pode render strike de direitos autorais." /> hint="Cortar live de terceiros sem autorização pode render strike de direitos autorais." />
</div> <div aria-live="polite" className="empty:hidden">{message && !message.ok && <Feedback ok={false}>{message.text}</Feedback>}</div>
<div className="flex flex-wrap items-center gap-3">
<Button disabled={disabled || pending !== null}>{pending === "add" ? <Spinner /> : <PlusIcon size={16} />}Adicionar fonte</Button>
</div>
<div aria-live="polite" className="empty:hidden">{message && <Feedback ok={message.ok}>{message.text}</Feedback>}</div>
</form> </form>
</Card> </Dialog>
); );
} }
export function ChannelList({ channels, accounts, onChanged, onConfigure, showEmotes }: { /** Idiomas conhecidos; um código fora da lista (do .env) entra para não sumir do seletor. */
channels: ClipperChannel[]; accounts: ChannelAccounts; onChanged: () => void; function languageOptions(current: string | undefined) {
/** Abre a "Configuração do corte" com o padrão do canal. */ if (!current || LANGUAGES.some((l) => l.id === current)) return LANGUAGES;
onConfigure: (channel: ClipperChannel) => void; return [...LANGUAGES, { id: current, label: languageLabel(current), short: current }];
/** O serviço novo (fase 2) tem a tabela de emotes. */
showEmotes: boolean;
}) {
if (channels.length === 0) {
return (
<EmptyState compact icon={<BroadcastIcon size={18} />} title="Nenhuma fonte cadastrada">
Adicione uma fonte acima. Com o monitor ligado, o Clipador grava sozinho sempre que ela entrar ao vivo.
</EmptyState>
);
}
return (
<ul className="grid divide-y divide-line overflow-hidden rounded-card border border-line bg-surface shadow-card">
{channels.map((c) => <li key={c.id}><ChannelRow channel={c} accounts={accounts[c.id] ?? []} onChanged={onChanged} onConfigure={onConfigure} showEmotes={showEmotes} /></li>)}
</ul>
);
} }
function ChannelRow({ channel: c, accounts, onChanged, onConfigure, showEmotes }: { /* ---------- Linha da fonte ---------- */
channel: ClipperChannel; accounts: { id: string; name: string }[]; onChanged: () => void;
onConfigure: (channel: ClipperChannel) => void; showEmotes: boolean; function SourceRow({ channel: c, accounts, showEmotes, onChanged, onConfigure }: {
channel: ClipperChannel; accounts: { id: string; name: string }[]; showEmotes: boolean; onChanged: () => void; onConfigure: () => void;
}) { }) {
const { pending, message, setMessage, run } = useClipperAction(onChanged); const { pending, message, setMessage, run } = useClipperAction(onChanged);
const [renaming, setRenaming] = useState(false); const [renaming, setRenaming] = useState(false);
const [emotesOpen, setEmotesOpen] = useState(false);
const [checked, setChecked] = useState<{ live: boolean; title: string } | null>(null); const [checked, setChecked] = useState<{ live: boolean; title: string } | null>(null);
const base = `channels/${encodeURIComponent(c.id)}`; const base = `channels/${encodeURIComponent(c.id)}`;
const name = c.displayName || c.channel; const name = c.displayName || c.channel;
const isLive = checked ? checked.live : c.lastStatus === "ao vivo"; const isLive = checked ? checked.live : c.lastStatus === "ao vivo";
const paused = c.monitor && Boolean(c.monitorPausedAt);
const busy = pending !== null;
const emotesId = useId();
const patch = (key: string, body: Partial<Pick<ClipperChannel, "displayName" | "monitor" | "authorized">>, text: string) => const patch = (key: string, body: Partial<Pick<ClipperChannel, "displayName" | "monitor" | "authorized" | "language">>, text: string) =>
run(key, () => clipperCall<ClipperChannel>(base, "PATCH", body), text); run(key, () => clipperCall<ClipperChannel>(base, "PATCH", body), text);
async function check() { async function check() {
@@ -97,43 +155,108 @@ function ChannelRow({ channel: c, accounts, onChanged, onConfigure, showEmotes }
if (r) setChecked(r); if (r) setChecked(r);
} }
const extra = (message || emotesOpen) && (
<tr className="border-t border-line/60 bg-sunken/30">
<td colSpan={7} className="px-4 py-3">
<div className="grid gap-3 sm:pl-[3.25rem]">
<div aria-live="polite" className="empty:hidden">{message && <Feedback ok={message.ok}>{message.text}</Feedback>}</div>
{emotesOpen && <div id={emotesId}><ChannelEmotes channelKey={c.id} title="Emotes da fonte" /></div>}
</div>
</td>
</tr>
);
return ( return (
<div className="grid gap-3 px-5 py-4"> <>
<div className="flex flex-wrap items-center gap-x-4 gap-y-3"> <tr className="border-t border-line transition-colors first:border-t-0 hover:bg-raised/40">
<Td>
<div className="flex items-center gap-3">
<span className="grid size-10 shrink-0 place-items-center rounded-control border border-line-strong bg-raised text-fg-muted"> <span className="grid size-10 shrink-0 place-items-center rounded-control border border-line-strong bg-raised text-fg-muted">
<PlatformIcon platform={c.platform} size={19} /> <PlatformIcon platform={c.platform} size={19} />
</span> </span>
<div className="grid min-w-44 flex-1 gap-1"> <div className="grid min-w-0 gap-0.5">
{renaming ? ( {renaming ? (
<form className="flex flex-wrap items-center gap-2" onSubmit={async (e) => { <form className="flex flex-wrap items-center gap-2" onSubmit={async (e) => {
e.preventDefault(); e.preventDefault();
const displayName = String(new FormData(e.currentTarget).get("displayName") ?? "").trim(); const displayName = String(new FormData(e.currentTarget).get("displayName") ?? "").trim();
if (await patch("rename", { displayName }, "Nome atualizado.")) setRenaming(false); if (await patch("rename", { displayName }, "Nome atualizado.")) setRenaming(false);
}}> }}>
<Input name="displayName" defaultValue={c.displayName} maxLength={60} autoFocus aria-label={`Nome da fonte ${c.channel}`} className="h-8 max-w-60" /> <Input name="displayName" defaultValue={c.displayName} maxLength={60} autoFocus aria-label={`Nome da fonte ${c.channel}`} className="h-8 w-48" />
<Button size="sm" variant="secondary" disabled={pending !== null}>{pending === "rename" ? <Spinner className="size-3.5" /> : <CheckIcon size={15} />}Salvar</Button> <Button size="sm" variant="secondary" disabled={busy}>{pending === "rename" ? <Spinner className="size-3.5" /> : "Salvar"}</Button>
<Button type="button" size="sm" variant="ghost" onClick={() => setRenaming(false)}>Cancelar</Button> <Button type="button" size="sm" variant="ghost" onClick={() => setRenaming(false)}>Cancelar</Button>
</form> </form>
) : ( ) : (
<p className="flex flex-wrap items-center gap-2"> <span className="flex items-center gap-1.5">
<span className="font-semibold text-fg">{name}</span> <span className="truncate font-medium text-fg">{name}</span>
<button type="button" onClick={() => { setRenaming(true); setMessage(null); }} aria-label={`Renomear ${name}`} <button type="button" onClick={() => { setRenaming(true); setMessage(null); }} aria-label={`Renomear ${name}`} title="Renomear"
className="grid size-6 place-items-center rounded text-fg-subtle hover:bg-raised hover:text-fg focus-visible:outline-2 focus-visible:outline-accent"> className="grid size-6 shrink-0 place-items-center rounded text-fg-subtle hover:bg-raised hover:text-fg focus-visible:outline-2 focus-visible:outline-accent">
<PenIcon size={13} /> <PenIcon size={13} />
</button> </button>
{isLive ? <Badge tone="danger" pulse>ao vivo</Badge> : c.lastStatus === "offline" || checked ? <Badge>offline</Badge> : null} </span>
{c.authorized
? <Badge tone="success">autorizado</Badge>
: <Badge tone="warning" dot={false}><AlertIcon size={12} />sem autorização · risco de strike</Badge>}
</p>
)} )}
<p className="flex flex-wrap items-center gap-x-3 gap-y-1 text-xs text-fg-subtle"> <span className="flex flex-wrap items-center gap-x-2 text-xs text-fg-subtle">
<span>{PLATFORM_LABEL[c.platform]}</span> <span>{PLATFORM_LABEL[c.platform]}</span>
<a href={c.url} target="_blank" rel="noreferrer noopener" className="hover:text-fg hover:underline">{c.url.replace(/^https?:\/\/(www\.)?/, "")}</a> <Dot />
<a href={c.url} target="_blank" rel="noreferrer noopener" className="truncate hover:text-fg hover:underline">{c.url.replace(/^https?:\/\/(www\.)?/, "")}</a>
<Dot />
<span>{c.lastCheckAt ? `checado ${formatRelative(c.lastCheckAt)}` : "nunca checado"}</span> <span>{c.lastCheckAt ? `checado ${formatRelative(c.lastCheckAt)}` : "nunca checado"}</span>
{accounts.length > 0 && ( </span>
<span className="inline-flex flex-wrap items-center gap-1.5"> </div>
<UsersIcon size={13} /> </div>
</Td>
<Td>
{isLive ? <Badge tone="danger" pulse>ao vivo</Badge> : c.lastStatus === "offline" || checked ? <Badge>offline</Badge> : <span className="text-fg-subtle">—</span>}
</Td>
<Td>
<div className="flex flex-wrap items-center gap-x-3 gap-y-1.5">
<Switch label={<span className="sr-only">Monitorar {name}</span>} checked={c.monitor} busy={pending === "monitor"} disabled={busy}
onChange={(v) => void patch("monitor", { monitor: v }, v ? "Monitor ligado: grava sozinho quando entrar ao vivo." : "Monitor desligado.")} />
{paused ? (
<span className="grid gap-1">
<span className="flex items-center gap-2">
<Badge tone="warning">pausado</Badge>
<Button size="sm" variant="secondary" disabled={busy} className="h-7"
onClick={() => void patch("resume", { monitor: true }, "Monitor religado: volta a gravar sozinho quando a fonte estiver ao vivo.")}>
{pending === "resume" ? <Spinner className="size-3.5" /> : <BroadcastIcon size={14} />}Religar
</Button>
</span>
<span className="text-xs text-fg-subtle">
você parou {c.monitorPausedBySession ? `a sessão #${c.monitorPausedBySession}` : "uma gravação"}
{c.monitorPausedAt ? ` ${formatRelative(c.monitorPausedAt)}` : ""}
</span>
</span>
) : (
<span className={cx("text-xs", c.monitor ? "text-fg-muted" : "text-fg-subtle")}>{c.monitor ? "grava sozinho" : "desligado"}</span>
)}
</div>
</Td>
<Td>
<div className="flex flex-wrap items-center gap-x-3 gap-y-1.5">
<Switch label={<span className="sr-only">O streamer autorizou cortes de {name}</span>} checked={c.authorized} busy={pending === "authorized"} disabled={busy}
onChange={(v) => void patch("authorized", { authorized: v }, v ? "Marcado como autorizado." : "Autorização desmarcada.")} />
{c.authorized
? <span className="text-xs text-fg-muted">autorizou cortes</span>
: <Badge tone="warning" dot={false}><AlertIcon size={12} />risco de strike</Badge>}
</div>
</Td>
<Td>
<Select aria-label={`Idioma da live de ${name}`} value={c.language ?? ""} disabled={busy || c.language === undefined}
title={c.language === undefined ? "O Clipador no ar ainda é a versão antiga: reinicie o serviço para escolher o idioma por fonte." : languageLabel(c.language)}
onChange={(e) => void patch("language", { language: e.target.value }, `Idioma da live: ${languageLabel(e.target.value)}.`)}
className="h-8 w-auto min-w-20 py-0 text-xs">
{c.language === undefined && <option value="">padrão</option>}
{languageOptions(c.language).map((l) => <option key={l.id} value={l.id}>{l.short} · {l.label}</option>)}
</Select>
</Td>
<Td>
{accounts.length > 0 ? (
<span className="inline-flex flex-wrap items-center gap-1.5 text-xs">
<UsersIcon size={13} className="text-fg-subtle" />
<span className="sr-only">Publicada pelos canais:</span> <span className="sr-only">Publicada pelos canais:</span>
{accounts.map((a, i) => ( {accounts.map((a, i) => (
<span key={a.id}> <span key={a.id}>
@@ -142,41 +265,60 @@ function ChannelRow({ channel: c, accounts, onChanged, onConfigure, showEmotes }
</span> </span>
))} ))}
</span> </span>
) : (
<Link href="/accounts" className="text-xs text-fg-subtle underline-offset-2 hover:text-fg hover:underline">ligar a um canal</Link>
)} )}
</p> </Td>
</div>
<div className="flex flex-wrap items-center gap-2"> <Td className="text-right">
<Button variant="ghost" size="sm" onClick={() => onConfigure(c)}><SettingsIcon size={15} />Padrão da fonte</Button> <div className="flex flex-wrap items-center justify-end gap-1">
<Button variant="secondary" size="sm" disabled={pending !== null} onClick={() => void check()}>
{pending === "check" ? <><Spinner className="size-3.5" />Checando…</> : <><RefreshIcon size={15} />Checar agora</>}
</Button>
{isLive && checked?.live && ( {isLive && checked?.live && (
<Button size="sm" disabled={pending !== null} <Button size="sm" disabled={busy}
onClick={() => void run("record", () => clipperCall<ClipperSession>("sessions", "POST", { url: c.url }), (s) => `Gravando: sessão #${s.id}.`)}> onClick={() => void run("record", () => clipperCall<ClipperSession>("sessions", "POST", { url: c.url }), (s) => `Gravando: sessão #${s.id}.`)}>
{pending === "record" ? <Spinner className="size-3.5" /> : <BroadcastIcon size={15} />}Gravar agora {pending === "record" ? <Spinner className="size-3.5" /> : <BroadcastIcon size={15} />}Gravar agora
</Button> </Button>
)} )}
<Button variant="ghost" size="sm" disabled={pending !== null} aria-label={`Remover a fonte ${name}`} <Button variant="secondary" size="sm" disabled={busy} onClick={() => void check()}>
{pending === "check" ? <Spinner className="size-3.5" /> : <RefreshIcon size={15} />}Checar agora
</Button>
<IconAction label="Padrão da fonte (layout, legenda, duração)" onClick={onConfigure}><SettingsIcon size={16} /></IconAction>
{showEmotes && (
<IconAction label="Emotes da fonte" pressed={emotesOpen} controls={emotesId} onClick={() => setEmotesOpen((o) => !o)}>
<ChatIcon size={16} /><ChevronDownIcon size={12} className={cx("transition-transform", emotesOpen && "rotate-180")} />
</IconAction>
)}
<IconAction label={`Remover a fonte ${name}`} danger disabled={busy}
onClick={async () => { onClick={async () => {
if (!(await askConfirm({ title: `Remover a fonte “${name}”?`, if (!(await askConfirm({ title: `Remover a fonte “${name}”?`,
message: "Ela deixa de ser monitorada. Sessões e cortes já gravados continuam.", message: "Ela deixa de ser monitorada. Sessões e cortes já gravados continuam.",
confirmLabel: "Remover fonte", tone: "danger" }))) return; confirmLabel: "Remover fonte", tone: "danger" }))) return;
void run("delete", () => clipperCall(base, "DELETE"), "Fonte removida."); void run("delete", () => clipperCall(base, "DELETE"), "Fonte removida.");
}}> }}>
{pending === "delete" ? <Spinner className="size-3.5" /> : <TrashIcon size={15} />}Remover {pending === "delete" ? <Spinner className="size-3.5" /> : <TrashIcon size={16} />}
</Button> </IconAction>
</div>
</div>
<div className="flex flex-wrap gap-x-8 gap-y-3 sm:pl-14">
<Switch label="Monitorar" checked={c.monitor} busy={pending === "monitor"} disabled={pending !== null}
onChange={(v) => void patch("monitor", { monitor: v }, v ? "Monitor ligado: grava sozinho quando entrar ao vivo." : "Monitor desligado.")}
hint="Grava sozinho quando entra ao vivo" />
<Switch label="Autorizou cortes" checked={c.authorized} busy={pending === "authorized"} disabled={pending !== null}
onChange={(v) => void patch("authorized", { authorized: v }, v ? "Marcado como autorizado." : "Autorização desmarcada.")}
hint="O streamer permitiu publicar cortes" />
</div>
{showEmotes && <div className="sm:pl-12"><ChannelEmotes channelKey={c.id} /></div>}
<div aria-live="polite" className="empty:hidden sm:pl-14">{message && <Feedback ok={message.ok}>{message.text}</Feedback>}</div>
</div> </div>
</Td>
</tr>
{extra}
</>
);
}
function Dot() {
return <span aria-hidden="true" className="text-line-strong">·</span>;
}
/** Botão só de ícone (o rótulo vai para title e leitores de tela). */
function IconAction({ label, onClick, children, danger = false, disabled = false, pressed, controls }: {
label: string; onClick: () => void; children: ReactNode; danger?: boolean; disabled?: boolean; pressed?: boolean; controls?: string;
}) {
return (
<button type="button" onClick={onClick} aria-label={label} title={label} disabled={disabled}
aria-pressed={pressed} aria-controls={pressed !== undefined ? controls : undefined}
className={cx("inline-flex h-8 min-w-8 items-center justify-center gap-0.5 rounded-control px-1.5 text-fg-muted transition-colors",
"focus-visible:outline-2 focus-visible:outline-accent disabled:pointer-events-none disabled:opacity-45",
danger ? "hover:bg-danger-soft hover:text-danger" : "hover:bg-raised hover:text-fg", pressed && "bg-raised text-fg")}>
{children}
</button>
); );
} }
+63 -4
View File
@@ -6,7 +6,7 @@ import { apiCall, type ApiResult } from "./api-client";
import type { Tone } from "./ui"; import type { Tone } from "./ui";
export type ClipperPlatform = "twitch" | "youtube" | "kick"; export type ClipperPlatform = "twitch" | "youtube" | "kick";
export type JudgeProvider = "codex" | "claude" | "off"; export type JudgeProvider = "codex" | "claude" | "gemini" | "off";
export type ClipperStatus = { export type ClipperStatus = {
version: string; version: string;
@@ -31,9 +31,20 @@ export type JudgeConfig = {
minScore: number; minScore: number;
options?: JudgeOptions; options?: JudgeOptions;
lastScanError?: string | null; lastScanError?: string | null;
models: { codex: JudgeModel[]; claude: JudgeModel[]; defaults: { codex: string; claude: string } }; /** `gemini` é opcional: o serviço antigo (antes do Gemini) não manda. */
models: { codex: JudgeModel[]; claude: JudgeModel[]; gemini?: JudgeModel[]; defaults: { codex: string; claude: string; gemini?: string } };
/** Por que a IA escolhida não roda (desligada em Configurações → IA, sem CLI, sem chave); null = pronta. */
unavailableReason?: string | null;
/** Modo de login da IA escolhida (Configurações → IA). */
authMode?: "oauth" | "apiKey" | null;
/** IA reserva: ordem efetiva em que o juiz tenta (a escolhida primeiro). Serviço antigo não manda. */
fallback?: { enabled: boolean; cooldownMin: number; chain: Exclude<JudgeProvider, "off">[] };
/** IAs em pausa depois de falha de indisponibilidade (`until` em ISO, UTC). */
pauses?: JudgePause[];
}; };
export type JudgePause = { provider: Exclude<JudgeProvider, "off">; until: string; reason: string };
export type ClipperChannel = { export type ClipperChannel = {
id: string; id: string;
platform: ClipperPlatform; platform: ClipperPlatform;
@@ -45,6 +56,12 @@ export type ClipperChannel = {
lastCheckAt: string | null; lastCheckAt: string | null;
lastStatus: "ao vivo" | "offline" | ""; lastStatus: "ao vivo" | "offline" | "";
createdAt: string; createdAt: string;
/** Idioma falado na live (transcrição e textos da IA). Opcional: o serviço antigo não manda (= padrão do serviço). */
language?: string;
/** Monitor pausado por você ter parado uma sessão à mão: não grava de novo até religar. Opcional (serviço antigo). */
monitorPausedAt?: string | null;
/** Sessão que você parou e motivou a pausa. */
monitorPausedBySession?: number | null;
}; };
export type SessionStatus = "starting" | "recording" | "processing" | "done" | "stopped" | "error" | "interrupted"; export type SessionStatus = "starting" | "recording" | "processing" | "done" | "stopped" | "error" | "interrupted";
@@ -82,6 +99,8 @@ export type ClipperSession = {
hasOwnSettings?: boolean; hasOwnSettings?: boolean;
/** O que a captura gravou de fato (1º bloco de cada execução). null = sessão antiga ou ainda sem bloco; ausente = serviço antigo. */ /** O que a captura gravou de fato (1º bloco de cada execução). null = sessão antiga ou ainda sem bloco; ausente = serviço antigo. */
capture?: CaptureInfo | null; capture?: CaptureInfo | null;
/** Idioma falado na live (copiado da fonte ao criar a sessão). Opcional: o serviço antigo não manda. */
language?: string;
}; };
export type GameSource = "platform" | "screen" | "user" | ""; export type GameSource = "platform" | "screen" | "user" | "";
@@ -159,6 +178,8 @@ export type Clip = {
edit?: { updatedAt: string; exportedAt: string | null; cover: string | null; origin?: "ai" | "user" | null } | null; edit?: { updatedAt: string; exportedAt: string | null; cover: string | null; origin?: "ai" | "user" | null } | null;
/** Formato do vídeo renderizado. Opcional: o serviço antigo não manda (ausente = vertical). */ /** Formato do vídeo renderizado. Opcional: o serviço antigo não manda (ausente = vertical). */
aspect?: Aspect; aspect?: Aspect;
/** Idioma da sessão de origem (resolvido pelo serviço). Opcional: o serviço antigo não manda (= padrão, pt-BR). */
language?: string;
}; };
/* ---------- Configuração do corte ---------- */ /* ---------- Configuração do corte ---------- */
@@ -254,15 +275,34 @@ export function layerFrom(draft: CutSettings, base: CutSettings, own: CutLayer |
/* ---------- Jogos e emotes ---------- */ /* ---------- Jogos e emotes ---------- */
/** Missão do jogo (só quando a lista já é pública): nome oficial, capítulo/ato, resumo e o que marca o fim dela. */
export type GameMission = { name: string; chapter: string; summary: string; completion_triggers: string[] };
export type GameProfile = { export type GameProfile = {
name: string; summary: string; genre: string; name: string; summary: string; genre: string;
mechanics: string[]; clip_worthy: string[]; avoid: string[]; jargon: string[]; news: string[]; sources: string[]; mechanics: string[]; clip_worthy: string[]; avoid: string[]; jargon: string[]; news: string[]; sources: string[];
/** Hashtags do jogo (a 1ª é a principal): entram em toda legenda de corte deste jogo, depois da do canal. */ /** Hashtags do jogo (a 1ª é a principal): entram em toda legenda de corte deste jogo, depois da do canal. */
hashtags?: string[]; hashtags?: string[];
// Opcionais: perfis antigos e o serviço antigo não mandam.
/** Outros nomes do jogo ("GTA 6", "GTA VI"): categoria e tela caem no mesmo perfil. */
aliases?: string[];
/** [] = a lista de missões ainda não é pública. */
missions?: GameMission[];
/** Sinais gerais de fim de missão/objetivo (banner, tela de resultado, fala): a IA termina o corte logo depois. */
end_triggers?: string[];
}; };
export type Game = { export type Game = {
id: string; name: string; status: "pending" | "ready" | "error"; error: string | null; id: string; name: string; status: "pending" | "ready" | "error"; error: string | null;
model: string | null; researchedAt: string | null; profile: GameProfile | null; model: string | null; researchedAt: string | null;
/** Perfil em português: o que o painel mostra. */
profile: GameProfile | null;
/** Perfil em inglês: o que vai para a IA. null/ausente = ainda não traduzido (a IA usa o `profile`). */
profileAi?: GameProfile | null;
/** Idioma do `profileAi` ("en-US"). */
aiLanguage?: string;
/** Quando uma versão foi gerada a partir da outra. */
translatedAt?: string | null;
/** União dos aliases das duas versões. */
aliases?: string[];
/** Última edição à mão ou por pedido seu à IA (serviço antigo não manda). */ /** Última edição à mão ou por pedido seu à IA (serviço antigo não manda). */
editedAt?: string | null; editedAt?: string | null;
/** Pedidos que você fez à IA; voltam em toda pesquisa nova. */ /** Pedidos que você fez à IA; voltam em toda pesquisa nova. */
@@ -321,6 +361,25 @@ export function useClipperAction(onDone?: () => void) {
return { pending, message, setMessage, run }; return { pending, message, setMessage, run };
} }
/* ---------- Idiomas ---------- */
/** Idiomas que o Clipador conhece (transcrição, textos da IA e público dos canais). O 1º é o padrão. */
export const LANGUAGES: { id: string; label: string; short: string }[] = [
{ id: "pt-BR", label: "Português (Brasil)", short: "PT" },
{ id: "en-US", label: "English (US)", short: "EN" },
{ id: "es-419", label: "Español (Latinoamérica)", short: "ES" },
];
/** Nome legível do idioma ("Português (Brasil)"); código desconhecido volta como está. */
export function languageLabel(code: string | null | undefined): string {
return LANGUAGES.find((l) => l.id === code)?.label ?? (code || "—");
}
/** Sigla curta do idioma ("PT", "EN"); código desconhecido vira a parte antes do hífen em maiúsculas. */
export function languageShort(code: string | null | undefined): string {
return LANGUAGES.find((l) => l.id === code)?.short ?? (code ? code.split("-")[0].toUpperCase() : "—");
}
/* ---------- Rótulos ---------- */ /* ---------- Rótulos ---------- */
export const PLATFORM_LABEL: Record<ClipperPlatform, string> = { twitch: "Twitch", youtube: "YouTube", kick: "Kick" }; export const PLATFORM_LABEL: Record<ClipperPlatform, string> = { twitch: "Twitch", youtube: "YouTube", kick: "Kick" };
@@ -376,7 +435,7 @@ export const MODE_LABEL: Record<LayoutMode, { label: string; hint: string }> = {
export const TAG_LABEL: Record<keyof ClipTags, string> = { risada: "risada", susto: "susto", hype: "hype", clip: "“clip” no chat" }; export const TAG_LABEL: Record<keyof ClipTags, string> = { risada: "risada", susto: "susto", hype: "hype", clip: "“clip” no chat" };
export const PROVIDER_LABEL: Record<JudgeProvider, string> = { codex: "Codex (GPT)", claude: "Claude", off: "Desligado" }; export const PROVIDER_LABEL: Record<JudgeProvider, string> = { codex: "Codex (GPT)", claude: "Claude", gemini: "Gemini", off: "Desligado" };
/** Sessões que ainda mudam sozinhas (vale consultar de novo). */ /** Sessões que ainda mudam sozinhas (vale consultar de novo). */
export const ACTIVE_SESSION: SessionStatus[] = ["starting", "recording", "processing"]; export const ACTIVE_SESSION: SessionStatus[] = ["starting", "recording", "processing"];
@@ -0,0 +1,192 @@
"use client";
// Modal de um corte: vídeo e sinais à esquerda; estado, publicação, veredito da IA, título/legenda, ajuste do trecho e
// transcrição à direita. No rodapé, anterior/próximo (percorre a lista filtrada, na ordem exibida; ← → no teclado
// fora de campos de texto), as ações da etapa e "Apagar". Aprovar ou rejeitar pula sozinho para o próximo corte
// (fluxo de decidir em sequência); sem próximo, fecha.
import { useEffect, useState } from "react";
import { CLIP_STATUS, SOURCE_LABEL, clipperCall, formatClock, formatDuration, languageLabel, useClipperAction, type Clip, type ClipperSession } from "./clipper-client";
import {
ChatSignals, ClipActions, ClipMedia, DeleteControl, FaceSignal, JudgeVerdict, TrimControl, situationLabel, type DeleteClip,
} from "./clipper-clip-parts";
import { Dialog } from "./dialog";
import { ArrowLeftIcon, ArrowRightIcon, CheckIcon, ClockIcon } from "./icons";
import type { PublishJob } from "./publishing-client";
import { PublishChips, TextLink } from "./publishing-ui";
import { Badge, Button, Feedback, Input, Spinner, Textarea, cx } from "./ui";
export function ClipDialog({ clip, name, session, position, onPrev, onNext, onClose, onChanged, publishJobs, onPublished, deleting, onDelete }: {
clip: Clip;
name: string;
session: ClipperSession | undefined;
/** Posição na lista filtrada (1-based) e total; null = o corte não está mais na lista exibida. */
position: { index: number; total: number } | null;
/** null = não há anterior/próximo. */
onPrev: (() => void) | null;
onNext: (() => void) | null;
onClose: () => void;
onChanged: () => void;
/** Jobs de publicação deste corte (etapa Aprovados); null = não lidos. */
publishJobs: PublishJob[] | null;
onPublished: () => void;
deleting: boolean;
onDelete: DeleteClip;
}) {
// ← → trocam de corte quando o foco não está num campo de texto (o vídeo tem as próprias teclas).
useEffect(() => {
const onKey = (e: KeyboardEvent) => {
if (e.defaultPrevented || e.altKey || e.ctrlKey || e.metaKey) return;
const t = e.target as HTMLElement | null;
if (t && (t.closest("input, textarea, select, video, [contenteditable=true]"))) return;
if (e.key === "ArrowLeft" && onPrev) { e.preventDefault(); onPrev(); }
if (e.key === "ArrowRight" && onNext) { e.preventDefault(); onNext(); }
};
document.addEventListener("keydown", onKey);
return () => document.removeEventListener("keydown", onKey);
}, [onPrev, onNext]);
const status = CLIP_STATUS[clip.status];
const situation = situationLabel(clip);
return (
<Dialog open onClose={onClose} size="lg" dismissOnBackdrop
eyebrow={<>Corte #{clip.id} · {name} · sessão #{clip.sessionId}</>}
title={clip.title || `Corte ${clip.id}`}
description={<span className="flex flex-wrap items-center gap-x-3 gap-y-1">
<Badge tone={status.tone} pulse={status.pulse}>{status.label}</Badge>
<span>{situation ?? SOURCE_LABEL[clip.source]}</span>
<span className="inline-flex items-center gap-1 tabular-nums"><ClockIcon size={13} />{formatDuration(clip.durationS)} · {formatClock(clip.startS)}–{formatClock(clip.endS)}</span>
{clip.aspect === "horizontal" && <span>horizontal 16:9</span>}
{session?.language && <span title="Idioma da live">{languageLabel(session.language)}</span>}
</span>}
footer={<ClipFooter key={clip.id} clip={clip} position={position} onPrev={onPrev} onNext={onNext} onClose={onClose}
onChanged={onChanged} publishJobs={publishJobs} onPublished={onPublished} deleting={deleting} onDelete={onDelete} />}>
<ClipBody key={clip.id} clip={clip} onChanged={onChanged} publishJobs={publishJobs} />
</Dialog>
);
}
/** Corpo do modal. `key` por corte: rascunho de título/legenda e versão do vídeo começam do zero a cada corte. */
function ClipBody({ clip, onChanged, publishJobs }: { clip: Clip; onChanged: () => void; publishJobs: PublishJob[] | null }) {
const { pending, message, run } = useClipperAction(onChanged);
const base = `clips/${clip.id}`;
const busy = clip.status === "candidate" || clip.status === "pending" || clip.status === "rendering";
const editable = !busy && clip.status !== "published";
// Rascunho de título e legenda: a consulta periódica não apaga o que está sendo digitado.
const [saved, setSaved] = useState({ title: clip.title, caption: clip.caption });
const [title, setTitle] = useState(clip.title);
const [caption, setCaption] = useState(clip.caption);
if (saved.title !== clip.title || saved.caption !== clip.caption) {
setSaved({ title: clip.title, caption: clip.caption });
if (title === saved.title) setTitle(clip.title);
if (caption === saved.caption) setCaption(clip.caption);
}
const textDirty = title !== clip.title || caption !== clip.caption;
// Versão do vídeo: muda quando um render termina (mesmo caminho de arquivo, conteúdo novo).
const [videoVersion, setVideoVersion] = useState(clip.updatedAt);
const [lastStatus, setLastStatus] = useState(clip.status);
if (lastStatus !== clip.status) {
setLastStatus(clip.status);
if (lastStatus === "candidate" || lastStatus === "pending" || lastStatus === "rendering") setVideoVersion(clip.updatedAt);
}
const showPublication = clip.status === "approved" || clip.status === "published";
return (
<div className="grid gap-6 md:grid-cols-[minmax(0,18rem)_minmax(0,1fr)]">
<div className="grid content-start gap-4">
<ClipMedia clip={clip} version={videoVersion} />
<ChatSignals clip={clip} />
<FaceSignal clip={clip} />
</div>
<div className="grid min-w-0 content-start gap-5">
{showPublication && (
<section aria-label="Publicação nas redes" className="grid gap-1.5">
<h3 className="text-eyebrow font-semibold text-fg-subtle uppercase">Publicação</h3>
{publishJobs
? <PublishChips jobs={publishJobs} showAccount={new Set(publishJobs.map((j) => j.accountId)).size > 1}
emptyText={<>Ainda não foi para nenhuma rede. Use “Publicar” abaixo para escolher o canal e as redes. <TextLink href="/publishing">Abrir Publicações</TextLink></>} />
: <p className="flex items-center gap-2 text-xs text-fg-subtle"><Spinner className="size-3.5" />Lendo o estado da publicação…</p>}
</section>
)}
<section aria-label="Veredito da IA" className="grid gap-3">
<JudgeVerdict clip={clip} />
</section>
{clip.status === "error" && clip.error && (
<p className="rounded-control border border-danger/30 bg-danger-soft px-3 py-2 font-mono text-xs break-words text-danger">{clip.error}</p>
)}
<form className="grid gap-3" onSubmit={(e) => {
e.preventDefault();
void run("text", () => clipperCall<Clip>(base, "PATCH", { title, caption }), "Título e legenda salvos.");
}}>
<label className="grid gap-1.5">
<span className="text-[0.8125rem] font-medium text-fg-muted">Título</span>
<Input value={title} onChange={(e) => setTitle(e.target.value)} maxLength={100} disabled={!editable} className="h-9" />
</label>
<label className="grid gap-1.5">
<span className="text-[0.8125rem] font-medium text-fg-muted">Legenda do post</span>
<Textarea value={caption} onChange={(e) => setCaption(e.target.value)} rows={3} maxLength={2200} disabled={!editable} className="text-[0.8125rem]" />
</label>
{textDirty && (
<div className="flex flex-wrap items-center gap-2">
<Button type="submit" variant="secondary" size="sm" disabled={pending !== null}>
{pending === "text" ? <Spinner className="size-3.5" /> : <CheckIcon size={15} />}Salvar texto
</Button>
<Button type="button" variant="ghost" size="sm" onClick={() => { setTitle(clip.title); setCaption(clip.caption); }}>Desfazer</Button>
</div>
)}
</form>
{editable && <TrimControl clip={clip} pending={pending} run={run} />}
{clip.transcript && (
<details className="group rounded-control border border-line bg-sunken/30 px-3 py-2 text-[0.8125rem]">
<summary className="cursor-pointer text-fg-muted select-none hover:text-fg">Transcrição</summary>
<p className="mt-2 leading-relaxed text-fg-muted">{clip.transcript}</p>
</details>
)}
<div aria-live="polite" className="empty:hidden">{message && <Feedback ok={message.ok}>{message.text}</Feedback>}</div>
</div>
</div>
);
}
/** Rodapé: anterior/próximo à esquerda, ações da etapa no meio, apagar à direita. */
function ClipFooter({ clip, position, onPrev, onNext, onClose, onChanged, publishJobs, onPublished, deleting, onDelete }: {
clip: Clip; position: { index: number; total: number } | null; onPrev: (() => void) | null; onNext: (() => void) | null; onClose: () => void;
onChanged: () => void; publishJobs: PublishJob[] | null; onPublished: () => void; deleting: boolean; onDelete: DeleteClip;
}) {
const { pending, message, setMessage, run } = useClipperAction(onChanged);
const publish = publishJobs ? { jobs: publishJobs, onDone: (m: { ok: boolean; text: string }) => { setMessage(m); onPublished(); } } : null;
return (
<div className="grid w-full gap-2">
<div className="flex w-full flex-wrap items-center gap-x-3 gap-y-2">
<div className="flex items-center gap-1" role="group" aria-label="Navegar entre os cortes da lista">
<Button variant="ghost" size="sm" disabled={!onPrev} onClick={() => onPrev?.()} aria-label="Corte anterior (seta para a esquerda)" title="Anterior (←)">
<ArrowLeftIcon size={15} />
</Button>
<span className="min-w-14 text-center text-xs text-fg-subtle tabular-nums">{position ? `${position.index} de ${position.total}` : "fora da lista"}</span>
<Button variant="ghost" size="sm" disabled={!onNext} onClick={() => onNext?.()} aria-label="Próximo corte (seta para a direita)" title="Próximo (→)">
<ArrowRightIcon size={15} />
</Button>
</div>
<ClipActions clip={clip} pending={pending} run={run} publish={publish} className="mx-auto"
onDecided={() => { if (onNext) onNext(); else onClose(); }} />
<div className={cx("ml-auto", !onNext && "")}>
<DeleteControl clip={clip} deleting={deleting} disabled={pending !== null}
onDelete={async (c, confirmPublished) => {
const ok = await onDelete(c, confirmPublished);
if (ok) { if (onNext) onNext(); else if (onPrev) onPrev(); else onClose(); }
return ok;
}} />
</div>
</div>
<div aria-live="polite" className="empty:hidden">{message && <Feedback ok={message.ok}>{message.text}</Feedback>}</div>
</div>
);
}
+429
View File
@@ -0,0 +1,429 @@
"use client";
// Peças de UM corte do Clipador, usadas pela lista (/clipper) e pelo modal do corte: vídeo/miniatura, veredito da IA
// (proposta da varredura, análise do analista, nota do editor), sinais do chat e do rosto, ajuste fino de início/fim,
// ações por etapa (aprovar, rejeitar, publicar, re-renderizar, mandar de novo para a IA, editar) e "Apagar" com
// confirmação curta no lugar. Nada aqui busca dados: tudo vem por props; cada ação chama `run` (useClipperAction).
import { useEffect, useRef, useState, type ReactNode } from "react";
import {
ACTIVE_CLIP, CLIP_STATUS, FACE_LABEL, SITUATION_LABEL, TAG_LABEL, UNDELETABLE_CLIP, aspectOf, clipperCall, formatClock, formatDuration, formatScore,
type Clip, type ClipAnalysis, type ClipTags, type Situation, type useClipperAction,
} from "./clipper-client";
import { ClipPublishButton } from "./clip-publish";
import { AlertIcon, CheckIcon, EyeIcon, RefreshIcon, ScissorsIcon, SparkIcon, TrashIcon, UndoIcon, XIcon } from "./icons";
import type { PublishJob } from "./publishing-client";
import { Badge, Button, LinkButton, Spinner, cx, fileUrl } from "./ui";
export type Run = ReturnType<typeof useClipperAction>["run"];
/** Apaga um corte; `confirmPublished` = o usuário já aceitou apagar só a cópia local de um corte publicado. */
export type DeleteClip = (clip: Clip, confirmPublished: boolean) => Promise<boolean>;
/** Duração mínima e máxima de um corte (limites do serviço; Shorts aceita até 180 s). */
export const MIN_CLIP_S = 5;
export const MAX_CLIP_S = 180;
/** Passos do ajuste: o início volta bastante (a ação costuma vir antes da reação); o fim estica um pouco. */
const START_STEPS = [-30, -10, -5, -2, 2] as const;
const END_STEPS = [-2, 2, 5, 10] as const;
/** O serviço recusa apagar enquanto a IA avalia (`candidate`) ou o FFmpeg renderiza (`rendering`). */
export function canDelete(clip: Clip): boolean {
return !UNDELETABLE_CLIP.includes(clip.status);
}
/** Nota da IA (0–10) do corte; `null` quando a IA ainda não julgou ou deu erro. */
export function judgeScore(clip: Clip): number | null {
return clip.judge && "score" in clip.judge ? clip.judge.score : null;
}
/** Situação que o analista viu ("falha engraçada", "lag ou bug"…), ou null sem análise. */
export function situationLabel(clip: Clip): string | null {
const a = clip.judge && "analysis" in clip.judge ? clip.judge.analysis : null;
if (!a?.situation) return null;
return SITUATION_LABEL[a.situation as Situation] ?? a.situation;
}
/* ---------- Apagar com confirmação no lugar ---------- */
export function DeleteControl({ clip, deleting, disabled, onDelete }: { clip: Clip; deleting: boolean; disabled: boolean; onDelete: DeleteClip }) {
const [asking, setAsking] = useState(false);
const openRef = useRef<HTMLButtonElement>(null);
const cancelRef = useRef<HTMLButtonElement>(null);
const wasAsking = useRef(false);
useEffect(() => {
// Foco: ao perguntar vai para Cancelar (Enter de novo não apaga por engano); ao desistir volta para Apagar.
if (asking) cancelRef.current?.focus();
else if (wasAsking.current) openRef.current?.focus();
wasAsking.current = asking;
}, [asking]);
const published = clip.status === "published";
if (!asking) {
return (
<Button ref={openRef} variant="ghost" size="sm" disabled={disabled || deleting} onClick={() => setAsking(true)}
className="text-fg-muted hover:bg-danger-soft hover:text-danger" aria-label={`Apagar o corte ${clip.id}`}>
{deleting ? <Spinner className="size-3.5" /> : <TrashIcon size={15} />}Apagar
</Button>
);
}
return (
<div role="group" aria-label={`Confirmar: apagar o corte ${clip.id}`}
onKeyDown={(e) => { if (e.key === "Escape") { e.stopPropagation(); setAsking(false); } }}
// Mesma altura do botão "Apagar" (h-8): perguntar não muda a altura do cartão.
className="flex flex-wrap items-center gap-2">
<span className="text-xs font-medium text-danger">{published ? "Publicado: apagar só a cópia local?" : "Apagar vídeo e edição?"}</span>
<Button variant="danger" size="sm" disabled={deleting}
onClick={async () => {
// Deu certo: o foco já foi para o aviso (o cartão vai sumir); não volta para cá.
if (await onDelete(clip, published)) wasAsking.current = false;
setAsking(false);
}}>
{deleting ? <Spinner className="size-3.5" /> : <TrashIcon size={15} />}Apagar
</Button>
<Button ref={cancelRef} variant="ghost" size="sm" disabled={deleting} onClick={() => setAsking(false)}>Cancelar</Button>
</div>
);
}
/* ---------- Cartão do corte ---------- */
export function ClipMedia({ clip, version }: { clip: Clip; version: string }) {
const busy = ACTIVE_CLIP.includes(clip.status);
const poster = clip.thumb ? fileUrl(clip.thumb) : undefined;
const frame = aspectOf(clip) === "horizontal" ? "aspect-video" : "aspect-9/16 max-sm:max-w-60";
if (clip.file && !busy) {
return (
<video key={version} controls preload="metadata" poster={poster} aria-label={`Vídeo do corte: ${clip.title || clip.id}`}
src={`${fileUrl(clip.file)}&v=${encodeURIComponent(version)}`}
className={cx(frame, "w-full self-start rounded-control border border-line bg-sunken object-contain")} />
);
}
return (
<div className={cx(frame, "relative grid w-full self-start overflow-hidden rounded-control border border-line bg-sunken")}>
{/* eslint-disable-next-line @next/next/no-img-element -- miniatura local servida por /api/files */}
{poster && <img src={poster} alt="" className="absolute inset-0 size-full object-cover opacity-35" />}
<div className="relative grid place-content-center justify-items-center gap-2 p-4 text-center text-xs text-fg-muted">
{busy ? <Spinner className="size-5 text-accent" /> : <ScissorsIcon size={22} className="text-fg-subtle" />}
<span>{busy ? CLIP_STATUS[clip.status].label : clip.status === "discarded" ? "Não renderizado: a IA descartou" : "Sem vídeo"}</span>
</div>
</div>
);
}
export function JudgeVerdict({ clip }: { clip: Clip }) {
const judge = clip.judge;
if (!judge) {
return (
<>
<Proposal clip={clip} />
<p className="flex items-center gap-2 text-xs text-fg-subtle">
<SparkIcon size={14} className={clip.status === "candidate" ? "text-violet" : undefined} />
{clip.status === "candidate" ? "A IA está avaliando este momento…"
: clip.source === "manual" ? "Corte manual: não passa pela IA."
: "Sem veredito da IA (juiz desligado ou avaliado só pela heurística)."}
</p>
</>
);
}
if ("error" in judge) {
return (
<>
<Proposal clip={clip} />
<p className="flex items-start gap-2 rounded-control border border-warning/25 bg-warning-soft px-3 py-2 text-xs text-warning">
<AlertIcon size={14} className="mt-px" />
<span>A IA não conseguiu avaliar: <span className="break-words">{judge.error}</span></span>
</p>
</>
);
}
const tone = judge.keep ? (judge.score >= 7 ? "text-success" : "text-fg") : "text-warning";
const a = judge.analysis;
return (
<>
<Proposal clip={clip} />
{a && <AnalysisView analysis={a} model={judge.analystModel} />}
<div className="grid grid-cols-[auto_minmax(0,1fr)] items-start gap-x-3.5 gap-y-1 rounded-control border border-violet/20 bg-violet-soft/40 px-3.5 py-2.5">
<div className="row-span-2 grid justify-items-center leading-none" aria-label={`Nota da IA: ${formatScore(judge.score)} de 10`}>
<span className={cx("font-display text-2xl font-semibold tabular-nums", tone)}>{formatScore(judge.score)}</span>
<span className="mt-1 text-[0.6875rem] text-fg-subtle">de 10</span>
</div>
<p className="flex flex-wrap items-center gap-2 text-xs">
<span className="inline-flex items-center gap-1.5 font-semibold text-violet"><SparkIcon size={13} />{a ? "Editor" : "Juiz"}</span>
<Badge tone={judge.keep ? "success" : "warning"} dot={false}>{judge.keep ? "manteve" : "descartou"}</Badge>
<span className="font-mono text-[0.6875rem] text-fg-subtle">{judge.model}</span>
</p>
{judge.reason && <p className="text-[0.8125rem] leading-relaxed text-fg-muted">{judge.reason}</p>}
</div>
</>
);
}
/** Corte da varredura (source "ai"): a proposta que a IA fez ao assistir a janela, antes dos juízes. */
export function Proposal({ clip }: { clip: Clip }) {
const r = clip.reasons ?? {};
if (clip.source !== "ai" || !(r.proposalTitle || r.proposalReason)) return null;
return (
<div className="grid gap-1 rounded-control border border-info/20 bg-info-soft/40 px-3.5 py-2.5 text-xs">
<p className="flex flex-wrap items-center gap-2">
<span className="inline-flex items-center gap-1.5 font-semibold text-info"><EyeIcon size={13} />Varredura viu na tela</span>
{r.proposalScore !== undefined && <Badge tone="info" dot={false}>proposta {formatScore(r.proposalScore)}/10</Badge>}
{r.scanFromS !== undefined && r.scanToS !== undefined && <span className="text-fg-subtle">janela {formatClock(r.scanFromS)}–{formatClock(r.scanToS)}</span>}
</p>
{r.proposalTitle && <p className="font-medium text-fg">{r.proposalTitle}</p>}
{r.proposalReason && <p className="leading-relaxed text-fg-muted">{r.proposalReason}</p>}
</div>
);
}
/** O que o ANALISTA (1º juiz) entendeu: situação, o que aconteceu, confiança; tela/fala/chat expansíveis. */
export function AnalysisView({ analysis: a, model }: { analysis: ClipAnalysis; model?: string }) {
const confidence = Math.round(Math.min(1, Math.max(0, a.confidence ?? 0)) * 100);
const details = [
{ label: "Tela", text: a.screen }, { label: "Fala", text: a.speech }, { label: "Chat", text: a.chat_meaning }, { label: "Gancho", text: a.hook },
].filter((d) => d.text);
return (
<div className="grid gap-2 rounded-control border border-line bg-sunken/40 px-3.5 py-2.5">
<p className="flex flex-wrap items-center gap-2 text-xs">
<span className="font-semibold text-fg">O que aconteceu</span>
<Badge tone="accent" dot={false}>{SITUATION_LABEL[a.situation as Situation] ?? a.situation}</Badge>
<span className={cx("tabular-nums", confidence >= 70 ? "text-success" : confidence >= 40 ? "text-fg-muted" : "text-warning")}>
confiança {confidence}%
</span>
{model && <span className="font-mono text-[0.6875rem] text-fg-subtle">analista {model}</span>}
</p>
{a.what_happened && <p className="text-[0.8125rem] leading-relaxed text-fg-muted">{a.what_happened}</p>}
{details.length > 0 && (
<details className="text-xs">
<summary className="cursor-pointer text-fg-subtle select-none hover:text-fg">Tela, fala e chat</summary>
<dl className="mt-2 grid gap-1.5">
{details.map((d) => (
<div key={d.label} className="grid grid-cols-[4.5rem_minmax(0,1fr)] gap-2">
<dt className="font-semibold text-fg-subtle">{d.label}</dt>
<dd className="leading-relaxed text-fg-muted">{d.text}</dd>
</div>
))}
</dl>
</details>
)}
</div>
);
}
export function ChatSignals({ clip }: { clip: Clip }) {
const { peakRatio, messages, tags, topMessages, emotes } = clip.reasons ?? {};
const tagEntries = Object.entries(tags ?? {}).filter(([, n]) => (n ?? 0) > 0) as [keyof ClipTags, number][];
const emoteEntries = Object.entries(emotes ?? {}).filter(([, n]) => n > 0).sort((x, y) => y[1] - x[1]);
if (peakRatio === undefined && messages === undefined && tagEntries.length === 0 && emoteEntries.length === 0 && !topMessages?.length) return null;
return (
<div className="grid gap-2">
<div className="flex flex-wrap items-center gap-1.5 text-xs">
{peakRatio !== undefined && <Chip strong>pico {formatScore(peakRatio)}× o normal</Chip>}
{messages !== undefined && <Chip>{messages} mensage{messages === 1 ? "m" : "ns"}</Chip>}
{tagEntries.map(([tag, n]) => <Chip key={tag} accent>{TAG_LABEL[tag] ?? tag} ×{n}</Chip>)}
</div>
{emoteEntries.length > 0 && (
<ul aria-label="Emotes do chat no pico" className="flex flex-wrap gap-1.5 text-xs">
{emoteEntries.slice(0, 8).map(([name, n]) => (
<li key={name} className="inline-flex h-6 items-center gap-1 rounded-full border border-option-b/25 bg-option-b-soft px-2.5 font-mono text-option-b">
{name}<span className="text-option-b/70">×{n}</span>
</li>
))}
</ul>
)}
{topMessages && topMessages.length > 0 && (
<ul aria-label="Mensagens do chat no pico" className="flex flex-wrap gap-1.5">
{topMessages.slice(0, 6).map((m, i) => (
<li key={i} title={m}
className="max-w-56 truncate rounded-lg border border-line bg-sunken/50 px-2 py-1 text-[0.75rem] text-fg-muted">
{m}
</li>
))}
</ul>
)}
</div>
);
}
/** Reação no rosto do streamer (rastreio local): rótulo, intensidade relativa ao normal dele e quando aconteceu. */
export function FaceSignal({ clip }: { clip: Clip }) {
const face = clip.reasons?.face;
if (!face || face.label === "neutro") return null;
const support = clip.reasons?.support;
return (
<p className="flex flex-wrap items-center gap-1.5 text-xs" aria-label="Reação no rosto do streamer">
<Chip accent>rosto: {FACE_LABEL[face.label] ?? face.label}{face.strong ? " forte" : ""}</Chip>
<span title="Quantos desvios acima do rosto normal deste streamer (3 = começa a contar; 6 ou mais = forte)">
<Chip>intensidade {formatScore(face.intensity)}</Chip>
</span>
<span className="text-fg-subtle" title={`começou em ${formatClock(face.onsetS)}`}>pico em {formatClock(face.peakS)}</span>
{clip.source === "face" && support && (
<span className="text-fg-subtle">com apoio {support.chatReactions >= 2 ? `do chat (${support.chatReactions} reações)` : "do áudio"}</span>
)}
</p>
);
}
function Chip({ children, strong = false, accent = false }: { children: ReactNode; strong?: boolean; accent?: boolean }) {
return (
<span className={cx("inline-flex h-6 items-center rounded-full border px-2.5 font-medium whitespace-nowrap",
accent ? "border-accent/25 bg-accent-soft text-accent" : strong ? "border-line-strong bg-raised text-fg" : "border-line bg-raised/60 text-fg-muted")}>
{children}
</span>
);
}
export function TrimControl({ clip, pending, run }: { clip: Clip; pending: string | null; run: Run }) {
const [trim, setTrim] = useState<{ start: number; end: number } | null>(null);
const start = trim?.start ?? clip.startS;
const end = trim?.end ?? clip.endS;
const dirty = trim !== null && (trim.start !== clip.startS || trim.end !== clip.endS);
const length = end - start;
const valid = length >= MIN_CLIP_S && length <= MAX_CLIP_S;
const nudge = (step: number, edge: "start" | "end") => {
const next = edge === "start" ? { start: Math.max(0, start + step), end } : { start, end: end + step };
const span = next.end - next.start;
const ok = span >= MIN_CLIP_S && span <= MAX_CLIP_S && !(edge === "start" && step < 0 && start <= 0);
const word = step < 0 ? "antes" : "depois";
return (
<button key={`${edge}${step}`} type="button" disabled={!ok || pending !== null} onClick={() => setTrim(next)}
aria-label={`${edge === "start" ? "Começar" : "Terminar"} ${Math.abs(step)} segundos ${word}`}
className={cx("h-7 rounded-md px-1.5 font-mono text-xs transition-colors hover:bg-overlay hover:text-fg focus-visible:outline-2 focus-visible:outline-accent disabled:opacity-40",
Math.abs(step) >= 10 ? "text-accent" : "text-fg-muted")}>
{step > 0 ? "+" : "−"}{Math.abs(step)} s
</button>
);
};
const delta = (now: number, was: number) => {
const d = Math.round(now - was);
return d === 0 ? null : <span className="text-accent"> ({d > 0 ? "+" : "−"}{Math.abs(d)} s)</span>;
};
return (
<fieldset className="grid gap-2">
<legend className="mb-1.5 text-[0.8125rem] font-medium text-fg-muted">Ajuste do trecho</legend>
<div className="flex flex-wrap items-center gap-2">
<span className="inline-flex flex-wrap items-center gap-0.5 rounded-control border border-line-strong bg-sunken/60 p-0.5">
{START_STEPS.filter((st) => st < 0).map((st) => nudge(st, "start"))}
<span className="px-1.5 text-xs text-fg-subtle">início <span className="font-mono text-fg tabular-nums">{formatClock(start)}</span>{delta(start, clip.startS)}</span>
{START_STEPS.filter((st) => st > 0).map((st) => nudge(st, "start"))}
</span>
<span className="inline-flex flex-wrap items-center gap-0.5 rounded-control border border-line-strong bg-sunken/60 p-0.5">
{END_STEPS.filter((st) => st < 0).map((st) => nudge(st, "end"))}
<span className="px-1.5 text-xs text-fg-subtle">fim <span className="font-mono text-fg tabular-nums">{formatClock(end)}</span>{delta(end, clip.endS)}</span>
{END_STEPS.filter((st) => st > 0).map((st) => nudge(st, "end"))}
</span>
<span className={cx("text-xs tabular-nums", !valid ? "text-danger" : dirty ? "text-accent" : "text-fg-subtle")}>{formatDuration(length)}</span>
</div>
{dirty && (
<div className="flex flex-wrap items-center gap-2">
<Button type="button" size="sm" variant="secondary" disabled={pending !== null || !valid}
onClick={async () => {
const done = await run("trim", () => clipperCall<Clip>(`clips/${clip.id}`, "PATCH", { startS: start, endS: end }),
"Novo trecho salvo. O corte voltou para a fila de render.");
if (done) setTrim(null);
}}>
{pending === "trim" ? <Spinner className="size-3.5" /> : <RefreshIcon size={15} />}Aplicar e re-renderizar
</Button>
<Button type="button" variant="ghost" size="sm" onClick={() => setTrim(null)}>Desfazer</Button>
<span className="text-xs text-fg-subtle">Entre {MIN_CLIP_S} e {MAX_CLIP_S} s. A gravação inteira fica guardada por cerca de 6 h.</span>
</div>
)}
</fieldset>
);
}
export function ClipActions({ clip, pending, run, publish, onDecided, className }: {
clip: Clip; pending: string | null; run: Run;
/** Aprovados/publicados: botão "Publicar" (null enquanto o estado da publicação não foi lido). */
publish: { jobs: PublishJob[]; onDone: (m: { ok: boolean; text: string }) => void } | null;
/** Depois de aprovar ou rejeitar com sucesso (o modal usa para pular ao próximo corte). */
onDecided?: () => void;
className?: string;
}) {
const base = `clips/${clip.id}`;
const icon = (key: string, fallback: ReactNode) => (pending === key ? <Spinner className="size-3.5" /> : fallback);
const setStatus = async (key: string, status: "approved" | "rejected" | "ready", text: string) => {
const done = await run(key, () => clipperCall<Clip>(base, "PATCH", { status }), text);
if (done && status !== "ready") onDecided?.();
return done;
};
const render = (text: string) => run("render", () => clipperCall<Clip>(`${base}/render`, "POST"), text);
const rejudge = () => run("rejudge", () => clipperCall<Clip>(`${base}/rejudge`, "POST"), "Mandado de novo para a IA.");
const disabled = pending !== null;
const rejudgeButton = clip.source !== "manual" && (
<Button variant="ghost" size="sm" disabled={disabled} onClick={() => void rejudge()}>
{icon("rejudge", <SparkIcon size={15} />)}Mandar de novo para a IA
</Button>
);
let buttons: ReactNode = null;
switch (clip.status) {
case "ready":
buttons = <>
<Button size="sm" disabled={disabled} onClick={() => void setStatus("approve", "approved", "Corte aprovado.")}>
{icon("approve", <CheckIcon size={15} />)}Aprovar
</Button>
<Button variant="secondary" size="sm" disabled={disabled} onClick={() => void setStatus("reject", "rejected", "Corte rejeitado.")}>
{icon("reject", <XIcon size={15} />)}Rejeitar
</Button>
<Button variant="ghost" size="sm" disabled={disabled} onClick={() => void render("Re-render pedido. O corte voltou para a fila.")}>
{icon("render", <RefreshIcon size={15} />)}Re-renderizar
</Button>
{rejudgeButton}
</>;
break;
case "approved":
buttons = <>
{publish && <ClipPublishButton clip={clip} jobs={publish.jobs} onDone={publish.onDone} />}
<Button variant="ghost" size="sm" disabled={disabled} onClick={() => void setStatus("undo", "ready", "Aprovação desfeita.")}>
{icon("undo", <UndoIcon size={15} />)}Desfazer aprovação
</Button>
</>;
break;
case "published":
// Publicado: dá para mandar para outra rede ou outro canal; editar não (o vídeo já está no ar).
return publish ? (
<div className={cx("flex flex-wrap items-center gap-2", className)}>
<ClipPublishButton clip={clip} jobs={publish.jobs} onDone={publish.onDone} variant="secondary" />
</div>
) : null;
case "rejected":
buttons = <>
{clip.file && <Button variant="secondary" size="sm" disabled={disabled} onClick={() => void setStatus("undo", "ready", "Corte de volta para aprovar.")}>
{icon("undo", <UndoIcon size={15} />)}Voltar para aprovar
</Button>}
<Button variant="ghost" size="sm" disabled={disabled} onClick={() => void render("Re-render pedido.")}>
{icon("render", <RefreshIcon size={15} />)}Re-renderizar
</Button>
</>;
break;
case "discarded":
buttons = <>
<Button variant="secondary" size="sm" disabled={disabled} onClick={() => void render("Render forçado: o corte entrou na fila.")}>
{icon("render", <ScissorsIcon size={15} />)}Forçar render
</Button>
{rejudgeButton}
</>;
break;
case "error":
buttons = <>
<Button variant="secondary" size="sm" disabled={disabled} onClick={() => void render("Tentando de novo: o corte entrou na fila.")}>
{icon("render", <RefreshIcon size={15} />)}Tentar render de novo
</Button>
{rejudgeButton}
</>;
break;
default:
// Na fila (esperando a IA ou o render): nada a decidir ainda; apagar fica com quem chama (DeleteControl).
return null;
}
return (
<div className={cx("flex flex-wrap items-center gap-2", className)}>
{buttons}
{/* Editor em tela cheia: abre o projeto que a IA montou (ou o seu) para ajustar e exportar de novo. */}
<LinkButton href={`/clipper/edit/${clip.id}`} variant="secondary" size="sm">
<ScissorsIcon size={15} />{clip.edit?.origin === "user" ? "Continuar edição" : "Editar"}
</LinkButton>
</div>
);
}
+233
View File
@@ -0,0 +1,233 @@
"use client";
// Lista de cortes: uma linha por corte com o que decide (miniatura, título, fonte/sessão/trecho, situação, nota da IA,
// duração, estado ou publicação, ações rápidas da etapa). Clique na linha (fora de botões) ou Enter abre o modal do
// corte; a linha aberta fica destacada. A caixa de seleção só aparece no hover/foco ou no modo de seleção.
import { type KeyboardEvent, type MouseEvent, type ReactNode } from "react";
import {
CLIP_STATUS, SOURCE_LABEL, clipperCall, formatClock, formatDuration, formatScore, languageShort, useClipperAction,
type Clip, type ClipperSession,
} from "./clipper-client";
import { ClipPublishButton } from "./clip-publish";
import { canDelete, judgeScore, situationLabel, type DeleteClip } from "./clipper-clip-parts";
import type { QueueFilter } from "./clipper-queue";
import { ArrowRightIcon, CheckIcon, RefreshIcon, ScissorsIcon, SparkIcon, UndoIcon, XIcon } from "./icons";
import type { PublishJob } from "./publishing-client";
import { PublishChips } from "./publishing-ui";
import { Badge, Button, Feedback, Spinner, Table, THead, Td, Th, cx, fileUrl, formatRelative } from "./ui";
export type ClipTableProps = {
clips: Clip[];
sessions: ClipperSession[];
stage: QueueFilter;
nameOf: (clip: Clip) => string;
/** Idioma padrão do serviço: só mostra o chip de idioma quando a sessão do corte difere dele. */
defaultLanguage: string;
/** Etapa Aprovados: jobs de publicação por id do corte (null = ainda não lidos / etapa não é Aprovados). */
publishing: Map<string, PublishJob[]> | null;
onPublished: () => void;
onChanged: () => void;
onOpen: (clip: Clip) => void;
/** Corte aberto no modal (linha destacada). */
openId: number | null;
/** Modo de seleção ligado: a caixa aparece em todas as linhas. */
revealed: boolean;
selected: ReadonlySet<number>;
onSelect: (id: number, on: boolean) => void;
deleting: ReadonlySet<number>;
onDelete: DeleteClip;
};
export function ClipTable(props: ClipTableProps) {
const { clips, stage } = props;
const approved = stage === "approved";
return (
<Table className="bg-surface shadow-card">
<THead>
<Th className="w-8"><span className="sr-only">Selecionar</span></Th>
<Th className="w-14"><span className="sr-only">Miniatura</span></Th>
<Th>Corte</Th>
<Th className="max-lg:hidden">Situação</Th>
<Th className="w-20 text-right">Nota IA</Th>
<Th className="w-20 text-right max-md:hidden">Duração</Th>
<Th className={approved ? "min-w-48" : "w-40"}>{approved ? "Publicação" : "Estado"}</Th>
<Th className="text-right"><span className="sr-only">Ações</span></Th>
</THead>
<tbody>
{clips.map((clip) => <ClipRow key={clip.id} clip={clip} {...props} />)}
</tbody>
</Table>
);
}
/** Clique num botão, link, input ou texto selecionado não conta como "abrir a linha". */
function isInteractive(target: EventTarget | null): boolean {
return target instanceof Element && Boolean(target.closest("button, a, input, select, textarea, label, [role=dialog], video"));
}
function ClipRow({ clip, sessions, stage, nameOf, defaultLanguage, publishing, onPublished, onChanged, onOpen, openId, revealed, selected, onSelect, deleting, onDelete }:
ClipTableProps & { clip: Clip }) {
const { pending, message, setMessage, run } = useClipperAction(onChanged);
const status = CLIP_STATUS[clip.status];
const isDeleting = deleting.has(clip.id);
const isSelected = selected.has(clip.id);
const open = openId === clip.id;
const name = nameOf(clip);
const title = clip.title || `Corte ${clip.id}`;
const session = sessions.find((s) => s.id === clip.sessionId);
const language = session?.language;
const score = judgeScore(clip);
const kept = clip.judge && "keep" in clip.judge ? clip.judge.keep : null;
const situation = situationLabel(clip);
const jobs = publishing?.get(String(clip.id)) ?? null;
const horizontal = clip.aspect === "horizontal";
const poster = clip.thumb ? fileUrl(clip.thumb) : null;
const onRowClick = (e: MouseEvent<HTMLTableRowElement>) => {
if (isInteractive(e.target) || window.getSelection()?.toString()) return;
onOpen(clip);
};
const onRowKey = (e: KeyboardEvent<HTMLTableRowElement>) => {
if (e.target !== e.currentTarget) return;
if (e.key === "Enter" || e.key === " ") { e.preventDefault(); onOpen(clip); }
};
return (
<>
<tr tabIndex={0} aria-label={`Abrir o corte: ${title}`} onClick={onRowClick} onKeyDown={onRowKey} aria-current={open ? "true" : undefined}
className={cx("group/row cursor-pointer border-t border-line transition-colors first:border-t-0 focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-accent",
open ? "bg-accent-soft/40" : isSelected ? "bg-raised/70" : "hover:bg-raised/40",
isDeleting && "opacity-50")}>
<Td className="pr-0 pl-3">
<input type="checkbox" checked={isSelected} disabled={!canDelete(clip) || isDeleting}
onChange={(e) => onSelect(clip.id, e.target.checked)}
aria-label={`Selecionar o corte ${clip.id}: ${title}`}
title={canDelete(clip) ? "Selecionar para apagar" : "A IA ou o render está trabalhando neste corte"}
className={cx("size-4 cursor-pointer accent-accent transition-opacity duration-150 motion-reduce:transition-none disabled:cursor-not-allowed",
!canDelete(clip)
? (revealed ? "opacity-40" : "opacity-0 group-hover/row:opacity-40 group-focus-within/row:opacity-40")
: revealed || isSelected ? "opacity-100" : "opacity-0 group-hover/row:opacity-100 group-focus-within/row:opacity-100")} />
</Td>
<Td className="px-2">
<span className={cx("relative grid shrink-0 place-items-center overflow-hidden rounded-md border border-line bg-sunken text-fg-subtle",
horizontal ? "h-9 w-16" : "h-16 w-9")}>
{/* eslint-disable-next-line @next/next/no-img-element -- miniatura local servida por /api/files */}
{poster ? <img src={poster} alt="" className="absolute inset-0 size-full object-cover" /> : <ScissorsIcon size={14} />}
</span>
</Td>
<Td>
<div className="grid min-w-0 max-w-[36rem] gap-0.5">
<p className="truncate font-medium text-fg" title={clip.title || undefined}>{title}</p>
<p className="flex flex-wrap items-center gap-x-2 text-xs text-fg-subtle">
<span className="text-fg-muted">{name}</span>
<span aria-hidden="true">·</span>
<span>sessão #{clip.sessionId}</span>
<span aria-hidden="true">·</span>
<span className="tabular-nums">{formatClock(clip.startS)}–{formatClock(clip.endS)}</span>
<span aria-hidden="true">·</span>
<span title={new Date(clip.createdAt).toLocaleString("pt-BR")}>{formatRelative(clip.createdAt)}</span>
{language && language !== defaultLanguage && (
<span className="rounded-sm border border-line-strong px-1 font-mono text-[0.625rem] text-fg-muted" title={`Idioma da live: ${language}`}>{languageShort(language)}</span>
)}
{horizontal && <span className="rounded-sm border border-line-strong px-1 text-[0.625rem] text-fg-muted">16:9</span>}
</p>
</div>
</Td>
<Td className="max-lg:hidden">
<span className="flex flex-wrap items-center gap-1.5">
{situation
? <Badge tone="accent" dot={false}>{situation}</Badge>
: <Badge tone={clip.source === "manual" ? "info" : clip.source === "ai" ? "violet" : "neutral"} dot={false}>{SOURCE_LABEL[clip.source]}</Badge>}
</span>
</Td>
<Td className="text-right">
{score === null
? <span className="text-fg-subtle" title={clip.source === "manual" ? "Corte manual: não passa pela IA" : "Sem nota da IA"}>—</span>
: <span className={cx("font-display text-lg font-semibold tabular-nums", kept === false ? "text-warning" : score >= 7 ? "text-success" : "text-fg")}
title={kept === false ? "A IA descartou" : "Nota da IA (0–10)"}>{formatScore(score)}</span>}
</Td>
<Td className="text-right text-fg-muted tabular-nums max-md:hidden">{formatDuration(clip.durationS)}</Td>
<Td>
{stage === "approved" && jobs
? <PublishChips jobs={jobs} emptyText={<span className="inline-flex items-center gap-1.5"><Badge tone={status.tone}>{status.label}</Badge><span>ainda não foi para nenhuma rede</span></span>} />
: <Badge tone={status.tone} pulse={status.pulse}>{status.label}</Badge>}
</Td>
<Td className="text-right">
<div className="flex items-center justify-end gap-1.5">
<QuickActions clip={clip} pending={pending} run={run} jobs={jobs}
onPublished={(m) => { setMessage(m); onPublished(); }} />
<Button variant="ghost" size="sm" onClick={() => onOpen(clip)} aria-label={`Abrir o corte: ${title}`} title="Abrir" className="text-fg-muted">
<ArrowRightIcon size={15} /><span className="max-xl:sr-only">Abrir</span>
</Button>
</div>
</Td>
</tr>
{(message || (clip.status === "error" && clip.error)) && (
<tr className="border-t-0">
<td colSpan={8} className="px-4 pt-0 pb-3">
<div aria-live="polite" className="grid gap-2">
{clip.status === "error" && clip.error && !message && (
<p className="truncate font-mono text-xs text-danger" title={clip.error}>{clip.error}</p>
)}
{message && <Feedback ok={message.ok}>{message.text}</Feedback>}
</div>
</td>
</tr>
)}
</>
);
}
type Run = ReturnType<typeof useClipperAction>["run"];
/** Ações rápidas da etapa, na própria linha (o resto fica no modal). */
function QuickActions({ clip, pending, run, jobs, onPublished }: {
clip: Clip; pending: string | null; run: Run; jobs: PublishJob[] | null; onPublished: (m: { ok: boolean; text: string }) => void;
}) {
const base = `clips/${clip.id}`;
const disabled = pending !== null;
const icon = (key: string, fallback: ReactNode) => (pending === key ? <Spinner className="size-3.5" /> : fallback);
const setStatus = (key: string, status: "approved" | "rejected" | "ready", text: string) =>
run(key, () => clipperCall<Clip>(base, "PATCH", { status }), text);
const render = (text: string) => run("render", () => clipperCall<Clip>(`${base}/render`, "POST"), text);
const label = clip.title || `corte ${clip.id}`;
switch (clip.status) {
case "ready":
return <>
<Button size="sm" disabled={disabled} onClick={() => void setStatus("approve", "approved", "Corte aprovado.")} aria-label={`Aprovar: ${label}`}>
{icon("approve", <CheckIcon size={15} />)}Aprovar
</Button>
<Button variant="ghost" size="sm" disabled={disabled} onClick={() => void setStatus("reject", "rejected", "Corte rejeitado.")} aria-label={`Rejeitar: ${label}`}>
{icon("reject", <XIcon size={15} />)}Rejeitar
</Button>
</>;
case "approved":
return <>
{jobs && <ClipPublishButton clip={clip} jobs={jobs} onDone={onPublished} />}
<Button variant="ghost" size="sm" disabled={disabled} onClick={() => void setStatus("undo", "ready", "Aprovação desfeita.")} aria-label={`Desfazer aprovação: ${label}`}>
{icon("undo", <UndoIcon size={15} />)}<span className="max-xl:sr-only">Desfazer</span>
</Button>
</>;
case "published":
return jobs ? <ClipPublishButton clip={clip} jobs={jobs} onDone={onPublished} variant="secondary" /> : null;
case "rejected":
return clip.file ? (
<Button variant="secondary" size="sm" disabled={disabled} onClick={() => void setStatus("undo", "ready", "Corte de volta para aprovar.")} aria-label={`Voltar para aprovar: ${label}`}>
{icon("undo", <UndoIcon size={15} />)}Voltar para aprovar
</Button>
) : null;
case "discarded":
return (
<Button variant="secondary" size="sm" disabled={disabled} onClick={() => void render("Render forçado: o corte entrou na fila.")} aria-label={`Forçar render: ${label}`}>
{icon("render", <ScissorsIcon size={15} />)}Forçar render
</Button>
);
case "error":
return (
<Button variant="secondary" size="sm" disabled={disabled} onClick={() => void render("Tentando de novo: o corte entrou na fila.")} aria-label={`Tentar render de novo: ${label}`}>
{icon("render", <RefreshIcon size={15} />)}Tentar de novo
</Button>
);
default:
return clip.status === "candidate" ? <span className="inline-flex items-center gap-1.5 text-xs text-violet"><SparkIcon size={13} />IA avaliando</span> : null;
}
}
+239
View File
@@ -0,0 +1,239 @@
"use client";
// Subpágina Cortes (/clipper): barra de filtros (etapa, fonte, sessão, idioma, ordenação, seleção), a lista e o modal
// do corte. O estado fica na URL — ?stage= ?source= ?session= ?lang= (replaceState) e ?clip= (pushState: o "voltar"
// do navegador fecha o modal). Ao abrir a página sem ?session, a lista já vem filtrada pela 1ª sessão gravando agora
// (pedido do dono, 17/11/2026); depois vale o que você escolher. Os dados vêm do ClipperProvider (layout).
import { useSearchParams } from "next/navigation";
import { Suspense, useCallback, useEffect, useMemo, useRef, useState } from "react";
import { LANGUAGES, channelFromUrl, languageLabel, type Clip } from "./clipper-client";
import { ClipDialog } from "./clipper-clip-dialog";
import { ClipTable } from "./clipper-clip-table";
import { canDelete } from "./clipper-clip-parts";
import { useClipper, useClipperData } from "./clipper-provider";
import {
DeleteToast, FilterLabel, QUEUE_FILTERS, QUEUE_SORTS, SelectionPill, StageFilter, TabMenu, useClipDeletion, useClipPublishing, useQueueSort,
type QueueFilter, type QueueSort,
} from "./clipper-queue";
import { CheckIcon, PublishIcon, ScissorsIcon } from "./icons";
import { TextLink } from "./publishing-ui";
import { Button, EmptyState, Select, Spinner, cx } from "./ui";
/** Valor de ?source= para cortes sem fonte cadastrada (link solto). */
const NO_SOURCE = "none";
export function ClipsPage() {
return (
<Suspense fallback={<div role="status" className="flex items-center gap-3 py-6 text-sm text-fg-muted"><Spinner />Carregando os cortes…</div>}>
<ClipsPageInner />
</Suspense>
);
}
/** Lê e grava os filtros na URL (replace) e o corte aberto (push). */
function useQueryState() {
const params = useSearchParams();
const set = useCallback((changes: Record<string, string | null>, mode: "replace" | "push" = "replace") => {
const next = new URLSearchParams(window.location.search);
for (const [k, v] of Object.entries(changes)) {
if (v === null || v === "") next.delete(k); else next.set(k, v);
}
const query = next.toString();
const url = `${window.location.pathname}${query ? `?${query}` : ""}${window.location.hash}`;
if (mode === "push") window.history.pushState(null, "", url);
else window.history.replaceState(null, "", url);
}, []);
return { params, set };
}
function ClipsPageInner() {
const { clips, sessions, channels, status } = useClipperData();
const { nameOfClip, reload } = useClipper();
const { params, set } = useQueryState();
const defaultLanguage = status.settings.language;
const stageParam = params.get("stage");
const stage: QueueFilter = QUEUE_FILTERS.some((f) => f.id === stageParam) ? (stageParam as QueueFilter) : "ready";
const source = params.get("source") ?? "";
const sessionParam = params.get("session");
const sessionFilter = sessionParam && /^\d+$/.test(sessionParam) ? Number(sessionParam) : null;
const lang = params.get("lang") ?? "";
const clipParam = params.get("clip");
const openId = clipParam && /^\d+$/.test(clipParam) ? Number(clipParam) : null;
const [sort, setSort] = useQueueSort();
// 1ª carga sem ?session na URL: filtra pela sessão gravando agora (pedido do dono, 17/11/2026) — mas só se ela
// já tiver algum corte; senão a lista abriria vazia com "98 para aprovar" no contador, e o filtro escondido confunde.
const autoPicked = useRef(false);
useEffect(() => {
if (autoPicked.current) return;
autoPicked.current = true;
if (sessionParam !== null || source) return;
const open = sessions.find((s) => s.status === "recording" || s.status === "starting");
if (open && clips.some((c) => c.sessionId === open.id)) set({ session: String(open.id) });
}, [sessions, clips, sessionParam, source, set]);
// Opções de fonte: fontes cadastradas que têm corte + "sem fonte" para cortes de link solto.
const sourceOptions = useMemo(() => {
const used = new Set(clips.map((c) => c.channelId ?? NO_SOURCE));
const list = channels.filter((c) => used.has(c.id)).map((c) => ({ id: c.id, label: c.displayName || c.channel }));
if (used.has(NO_SOURCE)) {
const urls = [...new Set(clips.filter((c) => !c.channelId).map((c) => channelFromUrl(c.sessionUrl)))];
list.push({ id: NO_SOURCE, label: urls.length === 1 ? `${urls[0]} (sem fonte cadastrada)` : "Sem fonte cadastrada" });
}
return list;
}, [clips, channels]);
const sessionById = useMemo(() => new Map(sessions.map((s) => [s.id, s])), [sessions]);
const languageOf = useCallback((c: Clip) => sessionById.get(c.sessionId)?.language ?? defaultLanguage, [sessionById, defaultLanguage]);
const languages = useMemo(() => [...new Set(clips.map(languageOf))], [clips, languageOf]);
// Escopo = filtros fora a etapa (as contagens das etapas valem para esse escopo).
const scoped = clips.filter((c) =>
(!source || (c.channelId ?? NO_SOURCE) === source)
&& (sessionFilter === null || c.sessionId === sessionFilter)
&& (!lang || languageOf(c) === lang));
const current = QUEUE_FILTERS.find((f) => f.id === stage)!;
const counts = Object.fromEntries(QUEUE_FILTERS.map((f) => [f.id, scoped.filter((c) => f.statuses.includes(c.status)).length])) as Record<QueueFilter, number>;
const compare = (QUEUE_SORTS.find((s) => s.id === sort) ?? QUEUE_SORTS[0]).compare;
const shown = scoped.filter((c) => current.statuses.includes(c.status)).sort(compare);
const sessionOptions = sessions.filter((s) => clips.some((c) => c.sessionId === s.id && (!source || (c.channelId ?? NO_SOURCE) === source)) || s.id === sessionFilter);
const publishing = useClipPublishing(stage === "approved");
// Seleção para apagar: vale só para o que está na lista (trocar de etapa ou de filtro limpa).
const [selected, setSelected] = useState<ReadonlySet<number>>(() => new Set());
const [selecting, setSelecting] = useState(false);
const { deleting, notice, setNotice, remove, confirmMany } = useClipDeletion(reload);
const selectable = shown.filter(canDelete);
const chosen = selectable.filter((c) => selected.has(c.id));
const working = deleting.size > 0;
const choosing = selecting || chosen.length > 0;
const exitSelecting = useCallback(() => { setSelecting(false); setSelected(new Set()); }, []);
const changeFilters = (changes: Record<string, string | null>) => { set(changes); exitSelecting(); };
useEffect(() => {
if (!choosing) return;
const onKey = (e: KeyboardEvent) => {
// Esc de um modal, menu ou confirmação da linha é deles (o modal nativo também dispara keydown aqui).
if (e.key !== "Escape" || e.defaultPrevented || document.querySelector("dialog[open]")) return;
exitSelecting();
};
document.addEventListener("keydown", onKey);
return () => document.removeEventListener("keydown", onKey);
}, [choosing, exitSelecting]);
const toggle = useCallback((id: number, on: boolean) => setSelected((prev) => {
const next = new Set(prev);
if (on) next.add(id); else next.delete(id);
return next;
}), []);
const forget = (gone: Set<number>) => setSelected((prev) => new Set([...prev].filter((id) => !gone.has(id))));
const scopeNote = sessionFilter !== null ? `Vale só para a sessão #${sessionFilter} (o filtro da lista). Os cortes das outras sessões ficam.`
: source ? `Vale só para a fonte filtrada (${sourceOptions.find((o) => o.id === source)?.label ?? source}). As outras ficam.`
: lang ? `Vale só para o idioma filtrado (${languageLabel(lang)}).` : null;
const deleteOne = useCallback(async (clip: Clip, confirmPublished: boolean) => {
const r = await remove([clip], confirmPublished);
forget(r.gone);
return r.ok;
}, [remove]);
// Modal: o corte aberto vem de TODOS os cortes (continua aberto mesmo se sair da etapa); anterior/próximo seguem a lista.
const openClip = openId !== null ? clips.find((c) => c.id === openId) ?? null : null;
const openIndex = openId !== null ? shown.findIndex((c) => c.id === openId) : -1;
const openAt = (clip: Clip | null, mode: "push" | "replace") => set({ clip: clip ? String(clip.id) : null }, mode);
const prev = openIndex > 0 ? shown[openIndex - 1] : null;
const next = openIndex >= 0 && openIndex < shown.length - 1 ? shown[openIndex + 1] : null;
const onPrev = prev ? () => openAt(prev, "replace") : null;
const onNext = next ? () => openAt(next, "replace") : null;
const close = useCallback(() => set({ clip: null }, "replace"), [set]);
// O corte aberto sumiu (apagado, ou a lista mudou e ele não existe mais): fecha.
useEffect(() => { if (openId !== null && clips.length > 0 && !clips.some((c) => c.id === openId)) close(); }, [openId, clips, close]);
return (
<section aria-labelledby="cortes-titulo" className="grid gap-4">
<h2 id="cortes-titulo" className="sr-only">Cortes</h2>
<div className="flex flex-wrap items-center gap-x-4 gap-y-3">
<StageFilter value={stage} counts={counts} onChange={(id) => changeFilters({ stage: id === "ready" ? null : id })} />
<div className="ml-auto flex min-w-0 flex-wrap items-center justify-end gap-x-3 gap-y-2">
{(sourceOptions.length > 1 || source) && (
<FilterLabel control={
<Select value={source} onChange={(e) => changeFilters({ source: e.target.value || null, session: null })} className="h-9 w-auto min-w-40" aria-label="Filtrar por fonte">
<option value="">Todas as fontes</option>
{sourceOptions.map((o) => <option key={o.id} value={o.id}>{o.label}</option>)}
</Select>}>Fonte</FilterLabel>
)}
{(sessionOptions.length > 1 || sessionFilter !== null) && (
<FilterLabel control={
<Select value={sessionFilter ?? ""} onChange={(e) => changeFilters({ session: e.target.value || null })} className="h-9 w-auto max-w-72 min-w-44" aria-label="Filtrar por sessão">
<option value="">Todas as sessões</option>
{sessionOptions.map((s) => (
<option key={s.id} value={s.id}>#{s.id} · {s.title || s.url.replace(/^https?:\/\/(www\.)?/, "")}</option>
))}
</Select>}>Sessão</FilterLabel>
)}
{(languages.length > 1 || lang) && (
<FilterLabel control={
<Select value={lang} onChange={(e) => changeFilters({ lang: e.target.value || null })} className="h-9 w-auto min-w-36" aria-label="Filtrar por idioma">
<option value="">Todos os idiomas</option>
{[...new Set([...languages, ...(lang ? [lang] : [])])].map((code) => (
<option key={code} value={code}>{LANGUAGES.find((l) => l.id === code)?.label ?? code}</option>
))}
</Select>}>Idioma</FilterLabel>
)}
<FilterLabel control={
<Select value={sort} onChange={(e) => setSort(e.target.value as QueueSort)} className="h-9 w-auto min-w-44" aria-label="Ordenar">
{QUEUE_SORTS.map((s) => <option key={s.id} value={s.id}>{s.label}</option>)}
</Select>}>Ordenar</FilterLabel>
{/* Sempre no lugar (mesmo vazio, desabilitado): ligar/desligar a seleção não mexe no layout. */}
<div className="flex items-center gap-0.5">
<Button variant="ghost" size="sm" aria-pressed={selecting} disabled={selectable.length === 0 || working}
onClick={() => (selecting ? exitSelecting() : setSelecting(true))} title="Escolher cortes para apagar (Esc sai)"
className={cx("text-fg-muted", selecting && "bg-raised text-fg")}>
<CheckIcon size={15} />{selecting ? "Selecionando" : "Selecionar"}
</Button>
<TabMenu count={selectable.length} disabled={selectable.length === 0 || working}
onDeleteAll={() => void confirmMany(selectable, "tab", { stageLabel: current.label, shownCount: shown.length, scopeNote }).then(forget)} />
</div>
</div>
</div>
{stage === "approved" && (
<p className="flex flex-wrap items-center gap-x-2 gap-y-1 text-xs leading-relaxed text-fg-muted">
<PublishIcon size={14} className="text-fg-subtle" />
{publishing.error
? <span className="text-warning">Não deu para ler o estado da publicação agora ({publishing.error}).</span>
: <span>“Publicar” escolhe o canal, as redes e quando sai. Fonte ligada a um canal publica os aprovados sozinha. A coluna Publicação mostra o estado em cada rede.</span>}
<TextLink href="/publishing">Abrir Publicações</TextLink>
</p>
)}
{shown.length === 0 ? (
<EmptyState compact icon={<ScissorsIcon size={18} />} title={`Nenhum corte em “${current.label}”`}>
{current.empty}
{sessionFilter !== null && <> Filtrando pela sessão #{sessionFilter}.</>}
{source && <> Filtrando por fonte.</>}
</EmptyState>
) : (
<ClipTable clips={shown} sessions={sessions} stage={stage} nameOf={nameOfClip} defaultLanguage={defaultLanguage}
publishing={stage === "approved" ? publishing.byClip : null} onPublished={publishing.reload} onChanged={reload}
onOpen={(clip) => openAt(clip, "push")} openId={openId}
revealed={choosing} selected={selected} onSelect={toggle} deleting={deleting} onDelete={deleteOne} />
)}
{openClip && (
<ClipDialog clip={openClip} name={nameOfClip(openClip)} session={sessionById.get(openClip.sessionId)}
position={openIndex >= 0 ? { index: openIndex + 1, total: shown.length } : null}
onPrev={onPrev} onNext={onNext} onClose={close} onChanged={reload}
publishJobs={stage === "approved" && publishing.byClip ? publishing.byClip.get(String(openClip.id)) ?? [] : null}
onPublished={publishing.reload} deleting={deleting.has(openClip.id)} onDelete={deleteOne} />
)}
{choosing && (
<SelectionPill chosen={chosen.length} total={selectable.length} working={working}
onSelectAll={(on) => setSelected(on ? new Set(selectable.map((c) => c.id)) : new Set())}
onDelete={() => void confirmMany(chosen, "selected", { stageLabel: current.label, shownCount: shown.length, scopeNote }).then(forget)}
onExit={exitSelecting} />
)}
{notice && <DeleteToast key={notice.key} notice={notice} raised={choosing} onClose={() => setNotice(null)} />}
</section>
);
}
@@ -0,0 +1,470 @@
"use client";
// Modal do jogo do Clipador: tudo o que a IA sabe de um jogo, em abas (Visão geral, Rende corte, Missões, Gatilhos
// de fim, Termos e hashtags, Fontes, Pedidos à IA), com a alternância Português (você lê) / English (vai para a IA).
// Rodapé: Pedir à IA (chat na seção da aba aberta), Editar (no idioma escolhido; o serviço traduz para o outro),
// Pesquisar de novo e Apagar. Usado pela página Jogos e pelo "O que a IA sabe do jogo" da sessão.
import { useId, useMemo, useState, type KeyboardEvent, type ReactNode } from "react";
import { askConfirm } from "./confirm-dialog";
import { clipperCall, type Game, type GameMission, type GameProfile } from "./clipper-client";
import {
AiChat, Chevron, CountPill, ListBlock, MISSION_SUGGESTIONS, ProfileEditor, SECTIONS, SavedNotes, aliasesOf, diffList, gamePath, missionNames,
monogram, useGameActions, type ChatTurn, type GamesReply, type ListKey, type RefineReply, type SectionKey,
} from "./clipper-game-parts";
import { Dialog } from "./dialog";
import { AlertIcon, BookIcon, GlobeIcon, LinkIcon, PenIcon, RefreshIcon, SearchIcon, SparkIcon, TrashIcon } from "./icons";
import { Badge, Button, EmptyState, Feedback, Input, Spinner, cx, formatRelative, hueOf } from "./ui";
type Language = "pt" | "en";
type TabId = "overview" | "clip" | "missions" | "triggers" | "terms" | "sources" | "notes";
/** Seção do chat para cada aba ("" = o perfil inteiro) e os atalhos de pedido. */
const TAB_SECTION: Record<TabId, { section: SectionKey; title: string; suggestions: string[] }> = {
overview: { section: "", title: "o perfil inteiro", suggestions: ["Deixe o resumo mais curto", "Acrescente as mecânicas da última atualização", "Pesquise as novidades deste mês"] },
clip: { section: "clip_worthy", title: SECTIONS.clip_worthy.title, suggestions: SECTIONS.clip_worthy.suggestions },
missions: { section: "missions", title: "Missões", suggestions: MISSION_SUGGESTIONS },
triggers: { section: "end_triggers", title: SECTIONS.end_triggers.title, suggestions: SECTIONS.end_triggers.suggestions },
terms: { section: "jargon", title: SECTIONS.jargon.title, suggestions: [...SECTIONS.jargon.suggestions, ...SECTIONS.hashtags.suggestions.slice(0, 1)] },
sources: { section: "sources", title: SECTIONS.sources.title, suggestions: ["Acrescente a wiki oficial do jogo como fonte"] },
notes: { section: "", title: "o perfil inteiro", suggestions: [] },
};
/** A lista de missões ganha busca a partir disto. */
const MISSION_SEARCH_FROM = 16;
export function GameDialog({ game, name, open, onClose, onGamesChanged }: {
/** undefined = o jogo ainda não está cadastrado no Clipador. */
game: Game | undefined; name: string; open: boolean; onClose: () => void; onGamesChanged: (games: Game[]) => void;
}) {
const { pending, message, setMessage, run } = useGameActions(onGamesChanged);
const [lang, setLang] = useState<Language>("pt");
const [tab, setTab] = useState<TabId>("overview");
const [editing, setEditing] = useState(false);
const [chatOpen, setChatOpen] = useState(false);
const [chatBusy, setChatBusy] = useState(false);
const [fresh, setFresh] = useState<Set<string>>(new Set()); // itens que a IA acabou de acrescentar (destaque)
const title = game?.profile?.name || game?.name || name;
const hue = hueOf(title);
const path = game ? gamePath(game.id) : "";
const busy = pending !== null || chatBusy || game?.status === "pending";
const shown: GameProfile | null | undefined = lang === "en" ? game?.profileAi : game?.profile;
const aliases = game ? aliasesOf(game) : [];
function close() {
setEditing(false);
setChatOpen(false);
setMessage(null);
onClose();
}
async function research() {
// Pesquisar refaz o perfil do zero: a edição à mão some; os pedidos guardados entram de novo na pesquisa.
if (game?.editedAt && !(await askConfirm({ title: "Pesquisar de novo?",
message: "Refaz o perfil do zero (em inglês, com missões e gatilhos) e apaga o que você editou à mão. Os pedidos que você fez à IA são aplicados de novo.",
confirmLabel: "Pesquisar de novo", tone: "danger" }))) return;
void run("research", () => clipperCall<GamesReply>(`${path}/research`, "POST"), "Pesquisa concluída e traduzida.", true);
}
async function remove() {
if (!game) return;
if (!(await askConfirm({ title: `Apagar o jogo “${title}”?`,
message: "O perfil, as missões e os pedidos guardados somem. As sessões não mudam; se o jogo voltar numa live, a IA pesquisa de novo.",
confirmLabel: "Apagar jogo", tone: "danger" }))) return;
const ok = await run("delete", () => clipperCall<GamesReply | null>(path, "DELETE"), "Jogo apagado.");
if (ok) close();
}
/** Manda um pedido do chat; aplica o perfil novo e devolve a resposta da IA + o que mudou (contado na versão em português). */
async function ask(section: SectionKey, instruction: string, search: boolean, history: ChatTurn[]): Promise<ChatTurn> {
if (!game) return { role: "ai", text: "Cadastre o jogo antes.", error: true };
setChatBusy(true);
const before = game.profile;
const r = await clipperCall<RefineReply>(`${path}/refine`, "POST", {
instruction, search, section, history: history.map(({ role, text }) => ({ role, text })),
});
setChatBusy(false);
if (!r.ok) {
if (search) {
const list = await clipperCall<GamesReply>("games");
if (list.ok) onGamesChanged(list.data.games);
}
return { role: "ai", text: r.error, error: true };
}
onGamesChanged(r.data.games);
const after = r.data.games.find((g) => g.id === game.id)?.profile;
let added = 0, removed = 0;
const nextFresh = new Set<string>();
for (const key of Object.keys(SECTIONS) as ListKey[]) {
const d = diffList(before?.[key], after?.[key]);
added += d.added.length;
removed += d.removed.length;
for (const item of d.added) nextFresh.add(`${key}:${item.toLowerCase()}`);
}
const m = diffList(missionNames(before), missionNames(after));
added += m.added.length;
removed += m.removed.length;
for (const item of m.added) nextFresh.add(`missions:${item.toLowerCase()}`);
setFresh(nextFresh);
return { role: "ai", text: r.data.reply || "Pronto, atualizei o perfil.", added, removed };
}
const status = !game ? <Badge>não cadastrado</Badge>
: game.status === "pending" ? <Badge tone="info" pulse>pesquisando na web</Badge>
: game.status === "error" ? <Badge tone="danger">erro na pesquisa</Badge>
: <Badge tone="success">pronto</Badge>;
const footer = game ? (
<>
<Button variant="ghost" size="sm" disabled={busy} onClick={() => void remove()}
className="mr-auto text-fg-muted hover:bg-danger-soft hover:text-danger">
{pending === "delete" ? <Spinner className="size-3.5" /> : <TrashIcon size={15} />}Apagar
</Button>
<Button variant="ghost" size="sm" disabled={busy || editing} onClick={() => void research()}>
{pending === "research" ? <><Spinner className="size-3.5" />Pesquisando…</> : <><RefreshIcon size={15} />{game.profile ? "Pesquisar de novo" : "Pesquisar"}</>}
</Button>
{shown && (
<Button variant="secondary" size="sm" disabled={busy || editing} onClick={() => { setEditing(true); setChatOpen(false); }}>
<PenIcon size={15} />Editar {lang === "en" ? "(inglês)" : "(português)"}
</Button>
)}
{game.profile && (
<Button size="sm" disabled={(busy && !chatBusy) || editing} aria-expanded={chatOpen} onClick={() => setChatOpen((o) => !o)}>
<SparkIcon size={15} />{chatOpen ? "Fechar IA" : "Pedir à IA"}
</Button>
)}
</>
) : (
<Button size="sm" disabled={pending !== null}
onClick={() => void run("create", () => clipperCall<GamesReply>("games", "POST", { name }), "Jogo cadastrado. Pesquisando na web… leva de 1 a 5 min.")}>
{pending === "create" ? <Spinner className="size-3.5" /> : <SparkIcon size={15} />}Cadastrar e pesquisar
</Button>
);
return (
<Dialog open={open} onClose={close} size="lg" dismissOnBackdrop={!editing}
eyebrow={<>{[shown?.genre || game?.profile?.genre, aliases.length ? aliases.slice(0, 3).join(" · ") : null].filter(Boolean).join(" · ") || "Jogo"}</>}
title={
<span className="flex items-center gap-3">
<span aria-hidden="true" className="grid size-9 shrink-0 place-items-center rounded-lg text-sm font-bold text-white"
style={{ background: `linear-gradient(135deg, hsl(${hue} 65% 52%), hsl(${(hue + 40) % 360} 70% 40%))` }}>
{monogram(title)}
</span>
{title}
</span>
}
description={
<span className="flex flex-wrap items-center gap-x-2 gap-y-1">
{status}
{game?.researchedAt && <span>pesquisado {formatRelative(game.researchedAt)}</span>}
{game?.editedAt && <span>· editado {formatRelative(game.editedAt)}</span>}
{game?.model && <span className="font-mono text-xs">· {game.model}</span>}
</span>
}
footer={footer}>
<div className="grid gap-4">
{!game ? (
<EmptyState compact icon={<BookIcon size={18} />} title="Jogo ainda não cadastrado">
A IA pesquisa o jogo na web (mecânicas, missões, gatilhos de fim, gírias, o que costuma render corte) e usa isso para entender a live.
</EmptyState>
) : (
<>
{game.status === "error" && game.error && <Feedback ok={false}>{game.error}</Feedback>}
{game.status === "pending" && (
<p role="status" className="flex items-center gap-2 rounded-control border border-info/25 bg-info-soft/50 px-3 py-2 text-xs text-info">
<Spinner className="size-3.5" />Pesquisando na web… leva de 1 a 5 min. Esta janela atualiza sozinha.
</p>
)}
{!editing && <LanguageSwitch value={lang} onChange={setLang} hasAi={Boolean(game.profileAi)} translatedAt={game.translatedAt ?? null} />}
{editing ? (
<ProfileEditor key={lang} profile={shown} fallbackName={game.name} language={lang} saving={pending === "save"}
onCancel={() => setEditing(false)}
onSave={async (profile) => {
const ok = await run("save", () => clipperCall<GamesReply>(`${path}?lang=${lang}`, "PUT", profile),
lang === "pt" ? "Perfil salvo. A versão da IA foi atualizada." : "Profile saved. A versão em português foi atualizada.");
if (ok) setEditing(false);
}} />
) : lang === "en" && !game.profileAi ? (
<div className="grid justify-items-start gap-3 rounded-control border border-warning/25 bg-warning-soft/60 px-4 py-3">
<p className="flex items-start gap-2 text-sm text-warning">
<AlertIcon size={15} className="mt-0.5 shrink-0" />
Este jogo ainda não tem a versão em inglês. Enquanto isso, a IA lê a versão em português.
</p>
<Button size="sm" variant="secondary" disabled={busy}
onClick={() => void run("translate", () => clipperCall<GamesReply>(`${path}/translate`, "POST"), "Versão da IA gerada.", true)}>
{pending === "translate" ? <Spinner className="size-3.5" /> : <GlobeIcon size={15} />}Gerar versão da IA
</Button>
</div>
) : shown ? (
<>
<ProfileTabs profile={shown} game={game} tab={tab} onTab={(t) => setTab(t)} />
{chatOpen && (
<AiChat key={tab} sectionTitle={TAB_SECTION[tab].title} suggestions={TAB_SECTION[tab].suggestions}
disabled={busy && !chatBusy} onAsk={(text, search, history) => ask(TAB_SECTION[tab].section, text, search, history)}
onClose={() => setChatOpen(false)} />
)}
<div role="tabpanel" id={`game-panel-${tab}`} aria-labelledby={`game-tab-${tab}`} className="grid gap-3">
<TabContent tab={tab} profile={shown} game={game} fresh={fresh} busy={busy}
onResearch={() => void research()}
onForget={(i) => void run("note", () => clipperCall<GamesReply>(`${path}/notes/${i}`, "DELETE"), "Pedido esquecido.")} />
</div>
</>
) : (
<EmptyState compact icon={<BookIcon size={18} />} title="Ainda sem perfil">
{game.status === "pending" ? "A pesquisa está em andamento." : "Use “Pesquisar” para a IA montar o perfil do jogo."}
</EmptyState>
)}
</>
)}
<div aria-live="polite" className="empty:hidden">{message && <Feedback ok={message.ok}>{message.text}</Feedback>}</div>
</div>
</Dialog>
);
}
/* ---------- Idioma ---------- */
function LanguageSwitch({ value, onChange, hasAi, translatedAt }: { value: Language; onChange: (v: Language) => void; hasAi: boolean; translatedAt: string | null }) {
const options: { id: Language; label: string; hint: string }[] = [
{ id: "pt", label: "Português", hint: "você lê" },
{ id: "en", label: "English", hint: "vai para a IA" },
];
return (
<div className="flex flex-wrap items-center gap-x-4 gap-y-2">
<div role="radiogroup" aria-label="Idioma do perfil" className="inline-flex rounded-control border border-line-strong bg-sunken/60 p-1">
{options.map((o) => {
const on = o.id === value;
return (
<button key={o.id} type="button" role="radio" aria-checked={on} onClick={() => onChange(o.id)}
className={cx("flex items-center gap-1.5 rounded-[0.45rem] px-3 py-1.5 text-[0.8125rem] font-medium transition-colors",
"focus-visible:outline-2 focus-visible:outline-offset-1 focus-visible:outline-accent",
on ? "bg-overlay text-fg shadow-[0_1px_3px_rgb(0_0_0/0.5)]" : "text-fg-muted hover:text-fg")}>
{o.label}<span className={cx("text-xs font-normal", on ? "text-fg-muted" : "text-fg-subtle")}>({o.hint})</span>
{o.id === "en" && !hasAi && <span aria-label="ainda não gerada" className="size-1.5 rounded-full bg-warning" />}
</button>
);
})}
</div>
{translatedAt && <span className="text-xs text-fg-subtle">versões sincronizadas {formatRelative(translatedAt)}</span>}
</div>
);
}
/* ---------- Abas ---------- */
function ProfileTabs({ profile: p, game, tab, onTab }: { profile: GameProfile; game: Game; tab: TabId; onTab: (t: TabId) => void }) {
const items: { id: TabId; label: string; count?: number }[] = [
{ id: "overview", label: "Visão geral" },
{ id: "clip", label: "Rende corte", count: (p.clip_worthy?.length ?? 0) + (p.avoid?.length ?? 0) },
{ id: "missions", label: "Missões", count: p.missions?.length ?? 0 },
{ id: "triggers", label: "Gatilhos de fim", count: p.end_triggers?.length ?? 0 },
{ id: "terms", label: "Termos e hashtags", count: (p.jargon?.length ?? 0) + (p.hashtags?.length ?? 0) },
{ id: "sources", label: "Fontes", count: p.sources?.length ?? 0 },
{ id: "notes", label: "Pedidos à IA", count: game.notes?.length ?? 0 },
];
function onKeyDown(e: KeyboardEvent<HTMLDivElement>) {
const i = items.findIndex((t) => t.id === tab);
const next = e.key === "ArrowRight" ? (i + 1) % items.length : e.key === "ArrowLeft" ? (i - 1 + items.length) % items.length
: e.key === "Home" ? 0 : e.key === "End" ? items.length - 1 : -1;
if (next < 0) return;
e.preventDefault();
onTab(items[next].id);
document.getElementById(`game-tab-${items[next].id}`)?.focus();
}
return (
<div role="tablist" aria-label="Partes do perfil do jogo" onKeyDown={onKeyDown}
className="-mx-1 flex gap-1 overflow-x-auto border-b border-line px-1 [scrollbar-width:none] [&::-webkit-scrollbar]:hidden">
{items.map((t) => {
const on = t.id === tab;
return (
<button key={t.id} id={`game-tab-${t.id}`} type="button" role="tab" aria-selected={on} aria-controls={`game-panel-${t.id}`}
tabIndex={on ? 0 : -1} onClick={() => onTab(t.id)}
className={cx("relative flex h-10 shrink-0 items-center gap-1.5 rounded-t-control px-2.5 text-[0.8125rem] font-medium whitespace-nowrap transition-colors",
"focus-visible:outline-2 focus-visible:outline-accent", on ? "text-fg" : "text-fg-muted hover:bg-raised/60 hover:text-fg")}>
{t.label}
{t.count !== undefined && <CountPill n={t.count} />}
{on && <span aria-hidden="true" className="absolute inset-x-2 -bottom-px h-0.5 rounded-full bg-accent" />}
</button>
);
})}
</div>
);
}
function TabContent({ tab, profile: p, game, fresh, busy, onResearch, onForget }: {
tab: TabId; profile: GameProfile; game: Game; fresh: Set<string>; busy: boolean; onResearch: () => void; onForget: (i: number) => void;
}) {
switch (tab) {
case "overview":
return (
<>
{p.summary ? <p className="max-w-[95ch] text-sm leading-relaxed text-fg-muted">{p.summary}</p>
: <p className="text-sm text-fg-subtle">Sem resumo.</p>}
<div className="grid gap-3 lg:grid-cols-2">
<ListBlock sectionKey="mechanics" items={p.mechanics ?? []} fresh={fresh} />
<ListBlock sectionKey="news" items={p.news ?? []} fresh={fresh} />
</div>
</>
);
case "clip":
return (
<div className="grid gap-3 lg:grid-cols-2">
<ListBlock sectionKey="clip_worthy" items={p.clip_worthy ?? []} fresh={fresh} />
<ListBlock sectionKey="avoid" items={p.avoid ?? []} fresh={fresh} />
</div>
);
case "missions":
return <MissionList missions={p.missions} fresh={fresh} busy={busy} onResearch={onResearch} />;
case "triggers":
return (
<>
<p className="text-xs leading-relaxed text-fg-subtle">
A IA usa estes sinais para terminar o corte no clímax de uma missão. Cada missão pode ter os próprios gatilhos, na aba Missões.
</p>
<ListBlock sectionKey="end_triggers" items={p.end_triggers ?? []} fresh={fresh} numbered />
</>
);
case "terms":
return (
<div className="grid gap-3">
<ListBlock sectionKey="jargon" items={p.jargon ?? []} fresh={fresh} chips />
<ListBlock sectionKey="hashtags" items={p.hashtags ?? []} fresh={fresh} chips />
<ListBlock sectionKey="aliases" items={p.aliases ?? aliasesOf(game)} fresh={fresh} chips />
</div>
);
case "sources":
return (p.sources ?? []).length === 0 ? <p className="text-sm text-fg-subtle">Nenhuma fonte registrada.</p> : (
<ol className="grid gap-1.5">
{p.sources.map((s, i) => (
<li key={i} className="flex min-w-0 items-center gap-2 text-[0.8125rem]">
<LinkIcon size={13} className="shrink-0 text-fg-subtle" />
{/^https?:\/\//.test(s)
? <a href={s} target="_blank" rel="noreferrer noopener" className="truncate text-fg-muted hover:text-fg hover:underline">{s.replace(/^https?:\/\/(www\.)?/, "")}</a>
: <span className="truncate text-fg-subtle">{s}</span>}
</li>
))}
</ol>
);
case "notes":
return <SavedNotes notes={game.notes ?? []} disabled={busy} onForget={onForget} />;
}
}
/* ---------- Missões ---------- */
function MissionList({ missions, fresh, busy, onResearch }: { missions: GameMission[] | undefined; fresh: Set<string>; busy: boolean; onResearch: () => void }) {
const [query, setQuery] = useState("");
const [openIndex, setOpenIndex] = useState<number | null>(null);
const searchId = useId();
const list = useMemo(() => (missions ?? []).map((m, i) => ({ m, i })), [missions]);
const needle = query.trim().toLowerCase();
const shown = needle
? list.filter(({ m }) => [m.name, m.chapter, m.summary].some((t) => (t ?? "").toLowerCase().includes(needle)))
: list;
if (!missions || missions.length === 0) {
return (
<EmptyState compact icon={<BookIcon size={18} />} title={missions ? "Lista de missões ainda não é pública" : "Sem missões neste perfil"}
action={<Button size="sm" variant="secondary" disabled={busy} onClick={onResearch}><RefreshIcon size={15} />Pesquisar de novo</Button>}>
{missions
? "A IA não achou uma lista confiável na web. Quando sair (wiki, guias), pesquise de novo ou peça à IA para acrescentar."
: "Este perfil é de antes das missões. Pesquise de novo para a IA procurar a lista e os gatilhos de fim."}
</EmptyState>
);
}
// Agrupa por capítulo, na ordem em que aparecem.
const groups: { chapter: string; rows: typeof shown }[] = [];
for (const row of shown) {
const chapter = row.m.chapter?.trim() || "";
const last = groups[groups.length - 1];
if (last && last.chapter === chapter) last.rows.push(row);
else groups.push({ chapter, rows: [row] });
}
const multipleChapters = groups.some((g) => g.chapter);
return (
<div className="grid gap-3">
<div className="flex flex-wrap items-center justify-between gap-2">
<p className="text-xs text-fg-subtle">
{missions.length} {missions.length === 1 ? "missão" : "missões"}. Clique numa missão para ver o que marca o fim dela.
</p>
{missions.length >= MISSION_SEARCH_FROM && (
<label htmlFor={searchId} className="relative block">
<span className="sr-only">Buscar missão</span>
<SearchIcon size={14} className="pointer-events-none absolute top-1/2 left-2.5 -translate-y-1/2 text-fg-subtle" />
<Input id={searchId} type="search" value={query} onChange={(e) => setQuery(e.target.value)} placeholder="Buscar missão…" className="h-8 w-52 pl-8 text-[0.8125rem]" />
</label>
)}
</div>
{shown.length === 0 ? <p className="text-sm text-fg-muted">Nenhuma missão com “{query.trim()}”.</p> : (
<div className="grid gap-3">
{groups.map((g, gi) => (
<section key={`${g.chapter}-${gi}`} aria-label={g.chapter || "Missões"} className="grid gap-1">
{multipleChapters && <h4 className="px-1 text-eyebrow font-semibold text-fg-subtle uppercase">{g.chapter || "Sem capítulo"}</h4>}
<ul className="grid divide-y divide-line overflow-hidden rounded-control border border-line bg-sunken/30">
{g.rows.map(({ m, i }) => (
<MissionRow key={i} mission={m} index={i} open={openIndex === i} isNew={fresh.has(`missions:${m.name.toLowerCase()}`)}
showChapter={!multipleChapters}
onToggle={() => setOpenIndex(openIndex === i ? null : i)} />
))}
</ul>
</section>
))}
</div>
)}
</div>
);
}
function MissionRow({ mission: m, index, open, isNew, showChapter, onToggle }: {
mission: GameMission; index: number; open: boolean; isNew: boolean;
/** Sem títulos de grupo (um capítulo só ou nenhum): o capítulo aparece dentro da missão. */
showChapter: boolean; onToggle: () => void;
}) {
const triggers = m.completion_triggers ?? [];
const panelId = `mission-${index}`;
return (
<li className={cx(isNew && "bg-success-soft/40")}>
<button type="button" aria-expanded={open} aria-controls={panelId} onClick={onToggle}
className="flex w-full items-center gap-3 px-3 py-2 text-left transition-colors hover:bg-raised/50 focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-accent">
<span className="w-6 shrink-0 text-right text-xs text-fg-subtle tabular-nums">{index + 1}</span>
<span className="grid min-w-0 flex-1">
<span className="truncate text-[0.8125rem] font-medium text-fg">{m.name}</span>
{m.summary && !open && <span className="truncate text-xs text-fg-subtle">{m.summary}</span>}
</span>
{isNew && <Badge tone="success" dot={false}>novo</Badge>}
<span className={cx("shrink-0 text-xs tabular-nums", triggers.length ? "text-accent" : "text-fg-subtle")}>
{triggers.length ? `${triggers.length} gatilho${triggers.length === 1 ? "" : "s"}` : "sem gatilho"}
</span>
<Chevron open={open} />
</button>
{open && (
<div id={panelId} className="grid gap-2 px-3 pt-1 pb-3 pl-12 text-[0.8125rem]">
{showChapter && m.chapter && <p className="text-xs text-fg-subtle">{m.chapter}</p>}
{m.summary && <p className="leading-relaxed text-fg-muted">{m.summary}</p>}
<div className="grid gap-1">
<p className="text-eyebrow font-semibold text-accent uppercase">Fim da missão</p>
{triggers.length === 0 ? <p className="text-xs text-fg-subtle">Sem gatilho próprio: valem os gatilhos gerais do jogo.</p> : (
<ol className="grid gap-1">
{triggers.map((t, j) => (
<li key={j} className="flex gap-2 text-fg-muted">
<span aria-hidden="true" className="mt-2 size-1.5 shrink-0 rounded-full bg-accent" />{t}
</li>
))}
</ol>
)}
</div>
</div>
)}
</li>
);
}
/** Rótulo curto do estado, reaproveitado pela tabela. */
export function GameStatusBadge({ game }: { game: Game }): ReactNode {
if (game.status === "pending") return <Badge tone="info" pulse>pesquisando</Badge>;
if (game.status === "error") return <span title={game.error ?? undefined}><Badge tone="danger">erro</Badge></span>;
return <Badge tone="success">pronto</Badge>;
}

Some files were not shown because too many files have changed in this diff Show More