Communitygithub.com

evalix098/tiktoklive

Sinais de entrada visíveis para o jogador em jogos de navegador: WASD, veículos, voo, mira de FPS e o modo de falha nº 1 (A/D invertido). Testes de auto-verificação de controle obrigatórios e uma pequena interface de teste para verificar se A vira à esquerda antes de enviar. Carregue para QUALQUER jogo com movimento, direção, voo, direção, tanques, barcos, mechas, drones, aviões, karts, câmeras de terceira pessoa — não apenas corrida. Aciona em "controls", "WASD", "inverted", "steer", "flight", "airplane", "kart", "vehicle", "yaw", "roll", "pitch", "mouse look", "A/D".

O que é tiktoklive?

Esta skill, 'Controls', fornece um conjunto rigoroso de regras e orientações para implementar controles de jogadores em jogos de navegador, com foco em evitar o erro comum de A/D invertido. Ela define os sinais visíveis para o jogador para movimento, direção de veículos e controle de voo, garantindo que a entrada do jogador corresponda à ação esperada na tela. A skill também inclui um processo de auto-verificação de controle obrigatório, com uma interface de teste mínima e um teste automatizado que pode ser executado via linha de comando para verificar se os controles estão corretos antes do lançamento. Ela é projetada para ser usada em conjunto com as skills 'building-games' e 'building-games/references/input.md' e aciona palavras-chave como 'controls', 'WASD', 'inverted', 'steer', 'flight' e outras relacionadas a gêneros de jogos.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/evalix098/tiktoklive/tree/HEAD/.grok/skills/controls

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Controles (sinais visíveis para o jogador — não envie invertido)

Leia isto do início ao fim antes de escrever código de movimento/direção/voom para qualquer jogo que use WASD, setas, câmera de perseguição ou uma aeronave. Não pule isto e abra apenas racing-kart ou fps — esses arquivos de gênero assumem que você já conhece esses sinais. A/D invertido é o bloqueador de envio mais comum em demonstrações de veículos e voo.

Combine com building-games (loop, câmera, orientação 3D) e building-games/references/input.md (estado de tecla pressionada, gamepad, toque). Esta skill é responsável por o que esquerda/direita/cima significam para o jogador e como você prova isso.


0. Regras rígidas (falhe a construção se quebrado)

  1. Esquerda/direita visível para o jogador é lei. De uma câmera de perseguição / atrás enquanto a nave se move para frente:
    • A / ← → o nariz (ou inclinação) vira para a esquerda na tela
    • D / → → o nariz (ou inclinação) vira para a direita na tela
  2. Nunca reutilize o strafe de FPS como direção de veículo. FPS “D → +vetor direito” é posição no plano do chão. A/D de veículo é taxa de guinada (ou rolamento), não um deslocamento de strafe. Misturá-los é a causa nº 1 de A/D invertido.
  3. Você deve executar um auto-teste de controle (§5) antes de dizer que está pronto. A garantia de qualidade apenas com captura de tela não é suficiente. Se A virar para a direita, inverta o sinal de direção/rolagem, reteste, então envie — não invente uma nova história de coordenadas.

1. Base 3D compartilhada (use isso em todos os lugares)

three.js: destro, +Y para cima, malhas voltadas para +Z, câmeras olham para −Z.

Direção apenas de guinada no XZ (veículos terrestres, andadores, a maioria das naves de arcade):

// guinada = 0 está voltado para −Z do mundo; +guinada é CCW sobre +Y (nariz se move em direção a −X)
frente = (-sin(yaw), 0, -cos(yaw))
direita = ( cos(yaw), 0, -sin(yaw))   // = normalize(cross(frente, mundoCima))

Com uma câmera de perseguição atrás da nave (câmera perto de posicao - frente * dist):

O jogador vêMundo (esta base)Entrada
Nariz para a esquerda+guinadaA / ← deve produzir +guinada (ou inclinação para a esquerda equivalente para aviões)
Nariz para a direita−guinadaD / → deve produzir −guinada

Se sua base for diferente, mantenha um par consistente — mas a linha visível para o jogador acima é obrigatória.


2. Mapas de gênero

2a. FPS / a pé (strafe, não direção)

W = +frente, S = −frente, D = +direita, A = −direita   // posição, não guinada
mouse: guinada -= movimentoX * sens; arfagem -= movimentoY * sens; limitar arfagem

Guinada do corpo para olhar; movimento usa apenas guinada (não aplique arfagem para andar).

2b. Veículo terrestre / aquático (kart, bicicleta, jet ski, barco, tanque, rover, moto de neve)

Corpo de arcade com direcao/guinada e velocidade para frente:

// Entrada (teclas pressionadas → ações uma vez por quadro)
let direcao = 0; // -1..+1, visível para o jogador
if (keys.has('KeyA') || keys.has('ArrowLeft'))  direcao += 1;  // ESQUERDA
if (keys.has('KeyD') || keys.has('ArrowRight')) direcao -= 1;  // DIREITA
// Opcional: direcao = clamp(direcao + gamepadX, -1, 1) com a mesma convenção de sinal

// Integrar (fatorVelocidade ~ 0..1 de |velocidade|)
const reverso = velocidade >= 0 ? 1 : -1; // roda-esquerda ainda parece esquerda em ré
guinada += direcao * taxaDeGiro * fatorVelocidade * reverso * dt;

// Mover ao longo da direção
const fx = -Math.sin(guinada), fz = -Math.cos(guinada);
posicao.x += fx * velocidade * dt;
posicao.z += fz * velocidade * dt;

Erro canônico (não copie):

// ERRADO — é isso que envia A/D invertido no mundo real
if (KeyA) direcao -= 1;
if (KeyD) direcao += 1;
guinada += direcao * taxaDeGiro * dt;  // A → −guinada → nariz DIREITO na câmera de perseguição

Se você já escreveu KeyA → direcao--, ou troque o mapeamento de tecla ou negue uma vez na integração (guinada += -direcao * …) — então execute §5. Não inverta duas vezes (teclas + integração + malha de inclinação).

2c. Voo de asa fixa (avião, planador, aeromodelo RC)

EntradaAçãoExpectativa do jogador
A / ←Rolar para a esquerda (aileron)Asa esquerda para baixo / inclinar para a esquerda
D / →Rolar para a direitaAsa direita para baixo / inclinar para a direita
W / ↑Arfagem (escolha um esquema e rotule o HUD)Geralmente nariz para baixo ou puxar para cima — seja consistente
S / ↓Arfagem oposta
Q / EGuinada / leme (opcional)Q esquerda, E direita
  • A/D não são strafe e não são “direção terrestre com sinais de FPS.”
  • Aplique a rolagem no eixo local para frente da nave com um sinal que corresponda a inclinar para a esquerda em A. Se a malha inclinar na direção errada, inverta um sinal na aplicação da rolagem (ou no mapeamento A/D → rolagem), não a base inteira.
  • Curva coordenada: a inclinação positiva deve produzir uma curva que corresponda à direção da inclinação sob a câmera de perseguição/externa.

2d. Helicóptero / drone / 6DOF

Documente o esquema em uma sobreposição inicial. Mínimo:

  • Acelerador/altitude em teclas discretas não deve grudar “sempre para cima” após um pressionamento (use estado pressionado ou para cima/para baixo explícito).
  • Strafe/guinada: A esquerda, D direita no quadro horizontal da nave (visível para o jogador).

2e. Side-scroller 2D / plataforma

D / → move-se para a direita na tela; A / ← move-se para a esquerda. Gravidade apenas invertida se o gênero for explicitamente de cabeça para baixo.


3. A câmera deve concordar

  • Câmera de perseguição: desejada = posicaoNave + cima*altura + frente*(-distanciaSeguimento); lerp; olharPara(nave).
  • Calcule a direcao (frente) uma vez tanto para o movimento quanto para a câmera — não reconstrua com sinal de guinada oposto no caminho da câmera.
  • Ordem de depuração: (1) teclas registram → (2) sinais corretos (§5) → (3) câmera concorda.

4. Encanação de entrada (breve)

  • Rastreie teclas com um Set em keydown/keyup usando event.code; limpe em blur / visibilitychange. Mova no loop do jogo com dt, não no manipulador de teclas.
  • Unifique teclado + toque + gamepad em ações (acelerador, direcao, arfagem, rolagem, …). Veja building-games/references/input.md.
  • Toque: stick esquerdo = mover/direção, direito = ações; alvos ≥44px.

5. Auto-teste de controle obrigatório (antes de "pronto")

Apenas captura de tela não é suficiente para qualquer nave com A/D.

5a. Lista de verificação visível para o jogador (cada construção de veículo / voo)

Enquanto se move para frente (velocidade > pequeno epsilon), câmera de perseguição atrás:

SegureDeve observar dentro de ~0.5s
ANariz ou inclinação move-se para a esquerda na tela
DNariz ou inclinação move-se para a direita na tela
W (terrestre)Velocidade aumenta / move-se ao longo do que está enfrentando
S (terrestre)Freios ou ré (conforme projetado)

Se A falhar: inverta o sinal de direção/rolagem uma vez, reteste A e D.

5b. Interface de teste mínima (implemente isto)

Exponha um pequeno gancho para que você (e QA automatizado) possa provar sinais sem adivinhar closures privadas:

// ex.: src/game/controlsTest.ts — dev/QA apenas é suficiente
export type ControlsProbe = {
  getYaw: () => number;       // radianos; ou getHeading()
  getSpeed: () => number;
  /** Injete ações pressionadas em vez de teclas reais; ambas permanecem aplicadas até que você
   *  as altere, para que §5c possa segurar uma tecla entre quadros e limpar no final. */
  setSteer?: (v: number) => void; // -1..1, mesmo sinal da produção
  setKeys?: (codes: string[]) => void; // pressionado até a próxima chamada; `[]` limpa
};

declare global {
  interface Window {
    __controlsTest?: ControlsProbe;
  }
}

Conecte window.__controlsTest do loop do jogo quando import.meta.env.DEV ou uma bandeira ?qa=1 estiver definida.

5c. Teste de fumaça automatizado (execute-o)

Dirija a sonda §5b com o CLI agent-browser pré-instalado — esse é o primeiro movimento, não um script escrito à mão. Um eval lançado sai com status não-zero; um meramente falso não sai, então afirme lançando. Execute-o como um batch — uma chamada CLI, não uma por verbo — recebendo JSON no stdin; --bail para no primeiro passo falho e sai com status não-zero.

agent-browser batch --bail <<'JSON'   # o rótulo do find é sensível a maiúsculas/minúsculas: copie-o de `snapshot -i`
[["open","http://127.0.0.1:8080/"],
 ["find","text","Start","click"],
 ["eval","if (!window.__controlsTest?.setKeys) throw Error('sem sonda §5b: adicione setKeys')"],
 ["eval","__controlsTest.setKeys(['KeyW'])"],
 ["wait","600"],
 ["eval","if (__controlsTest.getSpeed() <= 0.1) throw Error('W: sem movimento')"],
 ["eval","(async () => { const t = __controlsTest, y0 = t.getYaw(); t.setKeys(['KeyW','KeyA']); await new Promise(r => setTimeout(r, 300)); t.setKeys(['KeyW']); const d = t.getYaw() - y0, w = Math.atan2(Math.sin(d), Math.cos(d)); if (w < -0.05) throw Error('A vira para DIREITA — invertido, obteve ' + w.toFixed(2)); if (w <= 0.05) throw Error('A mal virou (' + w.toFixed(2) + ') — segure por mais tempo ou verifique se a sim está rodando'); return 'A ok' })()"],
 ["eval","__controlsTest.setKeys([])"],
 ["screenshot","/workspace/screenshots/controls.png"],
 ["close"]]
JSON

Segure teclas através da sonda, não com keydown — agent-browser keydown não atinge o Set da §4, então um jogo correto é lido como quebrado. Sem setKeys na sua sonda? Adicione-a (§5b), ou despache o evento de tecla você mesmo — a nota Keys da referência de QA do navegador tem o mecanismo e a forma.

A espera fica dentro de uma eval: espalhada por comandos, dura o tempo que eles levarem, e o wrap ±π em Math.atan2(Math.sin(d), Math.cos(d)) lê uma nave que virou mais de π como se estivesse virando para o outro lado. A IIFE é o que mantém o passo re-executável — um const d = … puro falha na segunda vez com "já declarado" — e async é o que permite que a espera execute no tempo da página. Repita para D com 'KeyD' e ambas as comparações espelhadas (w > 0.05 é invertido, w >= -0.05 é mal), entre aspas simples para que o JSON não precise de escapes; para aviões, afirme rolagem: A ⇒ inclinar para a esquerda.

A vira para DIREITA é o erro de sinal: inverta um sinal e re-execute. A mal virou não é — a nave se moveu na direção certa, apenas menos de 0,05 rad em 300 ms, o que um barco ou um rover pesado fará; aumente a espera, ou verifique se a sim está rodando, e não inverta nada. Qualquer outra saída não-zero — sem sonda, um daemon travado — significa que a verificação nunca foi executada: leia a mensagem primeiro. Leia os links AGENTS.md da referência de QA do navegador antes do seu primeiro fluxo — os verbos, as formas dos argumentos e o fallback estão lá.

5d. O que não fazer

  • Não teste apenas “D aumenta alguma variável interna.”
  • Não use FPS “D → +X quando voltado para −Z” como condição de aprovação do veículo.
  • Não inverta malha de inclinação, câmera e direção todos de uma vez ao corrigir — mude um sinal, reteste.

6. Critérios de conclusão (controles)

  • Abriu esta skill antes de escrever movimento/direção/voom.
  • Mapa de gênero escolhido (§2) e os rótulos da tela inicial / HUD correspondem a ele.
  • Teste visível para o jogador da câmera de perseguição A/D passou (§5a).
  • window.__controlsTest (ou equivalente) disponível em dev/QA e usado uma vez.
  • Nenhuma malha de inclinação invertida em relação à entrada de rolagem/direção.
  • Teclas são estado pressionado + escaladas por dt; nenhum empuxo pegajoso de um único toque de Espaço, a menos que intencional e rotulado.

Se alguma caixa não estiver marcada, o jogo não está pronto.

Individual skills in this repo

This repo contains 17 individual skills — each has its own dedicated page.

evalix098/tiktoklive

Add user accounts and sign-in to this TanStack Start app. Use when the app needs authentication, sign-in, user accounts, protected routes, or per-user data. Triggers on "auth", "login", "log in", "sign in", "sign up", "account", "users", "authentication", "protected", "who is logged in", "current user", "per-user".

evalix098/tiktoklive

Build browser games and interactive/canvas/3D experiences in this TanStack Start + React app. Use for any game, simulation, or WebGL/Canvas experience — 2D or 3D, single-player. Covers the game loop & timing, 3D orientation/camera conventions, collision, performance, assets, audio, save, game feel, and per-genre playbooks. For WASD / vehicle / flight **input signs and inverted A/D**, open the **`controls`** skill — do not rely on this file or racing-kart alone. Triggers on "game", "minecraft", "fps", "platformer", "racing", "tetris", "snake", "shooter", "3d", "three.js", "canvas", "voxel", "physics".

evalix098/tiktoklive

Design and build polished, non-generic UI for this TanStack Start + React + Tailwind v4 + shadcn/Radix app. Use whenever you create or restyle any interface surface — pages, landing pages, dashboards, forms, modals, nav, and game overlays (start screens, HUD, menus). Covers design tokens, layout, typography, color, spacing, motion, and the anti-"AI-slop" rules that keep output from looking generic. Triggers on "design", "UI", "make it look good", "polish", "landing page", "theme", "style", "redesign", "ugly", "clean up".

evalix098/tiktoklive

Deep guide for game ANIMATION assets: motion cycles, action keyframes, effect sequences, and animation sprite sheets — built around a video-first pipeline. In this app-builder sandbox, execute via the video2dsprite / generate2dsprite skills (magenta + scripts), not ad-hoc ffmpeg. Use whenever generating anything that moves: walk/run cycles, attacks, idles, FX, flags, fire, animation sheets. Complements game-asset-core.

evalix098/tiktoklive

Core discipline for ANY game-asset generation with Imagine tools: the engine-ready defaults users don't state, spec checklists, style anchoring, read-back verification, honest defect flagging. Use whenever generating any game art (sprites, sheets, animations, tiles, UI, FX) — then ALSO load the matching specialist skill: game-animation-frames for anything that moves, game-tilesets for tiles/terrain, game-character-consistency for recurring characters, game-ui-icons for UI and icons.

evalix098/tiktoklive

Deep guide for CHARACTER IDENTITY across images: turnarounds (front/side/ back), state and damage variants, palette swaps, equipment changes, and same-character-in-context sets. Use whenever generating character turnarounds, character sheets, variants of an existing sprite, or any same-subject multi-image set. Complements game-asset-core.

evalix098/tiktoklive

Deep guide for game TILE assets: seamless tileable textures, terrain transition tilesets, autotiles, and ground/platform tiles. Use whenever generating tileable textures, tilesets, terrain transitions, or seamless patterns. Complements game-asset-core.

evalix098/tiktoklive

Deep guide for game UI assets: buttons with interaction states, panels, bars, wordmark logos, and icon sets. Use whenever generating game UI elements, HUD assets, inventory icons, icon sets, buttons, or title logos. Complements game-asset-core.

evalix098/tiktoklive

Generate production-oriented 2D game maps with `imagine_text_to_image`: RPG/top-down maps, side-scroller parallax stages, tilemaps, layered raster maps, prop packs, collision zones, and walkable areas. Use when building browser games that need real map art (not pure code-drawn tiles), layered props, or map collision metadata. Triggers on "map", "level", "stage", "tilemap", "overworld", "dungeon", "side scroller background", "prop pack", "2D map".

evalix098/tiktoklive

Generate and postprocess 2D game sprites and animation sheets: pixel-art characters, NPCs, creatures, spells, projectiles, impacts, props, summons, and transparent PNG/GIF exports. Use when building browser games that need real sprite sheets (not code-drawn placeholders), matching a map art style, or producing magenta-background sheets for chroma-key cleanup. Triggers on "sprite", "sprite sheet", "animation sheet", "pixel art character", "walk cycle", "attack animation", "projectile sprite", "2D game asset".

evalix098/tiktoklive

How to use the Imagine tools in Grok Build: imagine_text_to_image, imagine_image_to_image, imagine_reference_to_image, imagine_text_to_video, imagine_image_to_video, imagine_reference_to_video, and render_file for chat previews. When to build a visual with code instead of generating it, prompt-craft, reference-first handling of real people, factual grounding, and asset-consistency. Load this whenever generating or editing an image or video is on the table. Tool-usage-driven, not triggered by a user merely mentioning images.

evalix098/tiktoklive

Peer-to-peer realtime multiplayer over WebRTC data channels: every user of the deployed app connects directly to every other user (full mesh), the server only brokers the handshake at /api/rtc. Lowest possible latency, zero per-message server cost. Use for 2-8 player co-op/casual realtime: shared cursors, drawing, party games, casual action. Triggers: p2p, peer to peer, webrtc, low latency multiplayer, direct connection.

evalix098/tiktoklive

Use Neon Postgres (the database) in this TanStack Start app. Use when the app needs to store or query data, persist state, or keep per-user data. Triggers on "database", "Postgres", "Neon", "save data", "store data", "persist", "tables", "SQL", "query", "migrations".

evalix098/tiktoklive

Share-link previews and app identity for apps on *.grok.me: the injector-owned og:image card, the SVG favicon, and PWA icons for installable apps. Use when scaffolding, renaming, or restyling the app — and for share / unfurl / OG / Twitter card questions. A custom 1200×630 card from the app's own art is the default — games of every kind (DOM board/word games included), whimsical apps, creative tools, and brand-forward pages; only plain utilities keep the placeholder. Always run the brand-asset pass as a `task` subagent and never wait for it. Triggers on "share", "rename", "app name", "OG", "Open Graph", "twitter card", "unfurl", "og:image", "og:type", "x:game:image", "x-banner", "link preview", "social card", "thumbnail", "preview image", "favicon", "app icon", "PWA", "manifest", "installable", "home screen", "SEO", "meta description".

evalix098/tiktoklive

Official Three.js API and TSL (Three.js Shading Language) reference for LLM code generation. Load when writing or debugging three.js / WebGL / WebGPU / custom materials / shaders / GLTF / advanced three APIs beyond basic game loop/controls. Prefer building-games for game correctness (loop, WASD, camera, orientation); use this skill for full API/TSL depth. Triggers on "three.js", "threejs", "WebGPU", "TSL", "NodeMaterial", "shader", "GLTF", "MeshStandard", "OrbitControls", "WebGLRenderer".

evalix098/tiktoklive

Grok Build only. Turn a 2D character still into denser animation sprites via imagine_text_to_image base → imagine_image_to_video (6s/10s run-in-place) → ffmpeg frames → magenta chroma-key → dense sampled strips/grids/GIFs. Use when the user wants video-to-sprite, smoother run/walk cycles, or denser intermediate poses. Prefer generate2dsprite for crisp production pixel sheets. Triggers on "video to sprite", "imagine_image_to_video sprite", "dense walk cycle", "smooth run animation from video".

evalix098/tiktoklive

Call the xAI API (Grok) from this app's server code using the injected XAI_API_KEY: chat/LLM features, image and video generation (Imagine), and voice (text-to-speech). Use when the app needs any "AI" / "assistant" / "chatbot" / "Grok" functionality, runtime image/video generation, or speech. Triggers on "AI", "LLM", "chatbot", "assistant", "Grok", "xAI", "generate text", "summarize", "generate image", "AI video", "voice", "text to speech", "TTS", "OpenAI" (use xAI instead).

Habilidades Relacionadas