Communitygithub.com

evalix098/tiktoklive

Panneaux de contrôle visibles par le joueur pour jeux navigateur : WASD, véhicules, vol, FPS avec visée souris, et le mode d'échec n°1 (A/D inversé). Tests de contrôle obligatoires et une mini interface de test pour vérifier que A tourne à gauche avant de livrer.

Qu'est-ce que tiktoklive ?

Ce skill fournit les conventions et les tests obligatoires pour les contrôles joueur dans les jeux navigateur 3D. Il couvre toute la gamme des genres : FPS, véhicules terrestres et aquatiques, avions, hélicoptères/drones, et jeux 2D. La règle d'or est que du point de vue du joueur, avec une caméra de poursuite, A/← doit faire tourner le nez ou l'inclinaison à gauche sur l'écran, et D/→ à droite. Le skill détaille les mappings pour chaque genre (yaw pur pour les véhicules, roulis pour les avions, déplacement latéral pour FPS) et fournit une base 3D partagée (three.js Y-up). Pour éviter le bug n°1 (A/D inversé) qui bloque souvent la livraison, il impose un auto-test obligatoire avant de terminer, avec une interface de test minimale (`window.__controlsTest`) et un script de test automatisé via l'outil `agent-browser`. Le skill s'applique à tout jeu avec mouvement, conduite, vol, etc., et se déclenche sur des mots-clés comme "controls", "WASD", "inverted", "steer", "flight". Il est conçu pour fonctionner sur n'importe quel environnement de développement web (par exemple, avec three.js) et insiste sur le fait que les tests par capture d'écran ne suffisent pas.

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

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Contrôles (panneaux visibles par le joueur — ne pas livrer inversé)

Lisez ceci de bout en bout avant d'écrire du code de mouvement/vol/virage pour tout jeu qui utilise WASD, les flèches, une caméra de poursuite ou un engin volant. Ne sautez pas cette étape et n'ouvrez pas uniquement racing-kart ou fps — ces fichiers de genre supposent que vous connaissez déjà ces conventions. L'inversion de A/D est le bloqueur de livraison le plus courant dans les démos de véhicules et de vol.

Associez avec building-games (boucle, caméra, orientation 3D) et building-games/references/input.md (état des touches, manette, tactile). Ce skill gère ce que gauche/droite/haut signifie pour le joueur et comment le prouver.


0. Règles strictes (la build échoue si non respectées)

  1. La gauche/droite visible par le joueur fait loi. Depuis une caméra de poursuite / par derrière tandis que l'engin se déplace en avant :
    • A / ← → le nez (ou l'inclinaison) tourne à gauche sur l'écran
    • D / → → le nez (ou l'inclinaison) tourne à droite sur l'écran
  2. Ne réutilisez jamais le strafe FPS pour le virage d'un véhicule. FPS « D → vecteur +right » est une position sur le plan au sol. Le A/D d'un véhicule est un taux de lacet (ou de roulis), pas un décalage latéral. Les mélanger est la cause n°1 de l'inversion de A/D.
  3. Vous devez exécuter un auto-test de contrôle (§5) avant de dire que c'est fini. Une QA par capture d'écran ne suffit pas. Si A tourne à droite, inversez le signe de virage/roulis, retestez, puis livrez — n'inventez pas une nouvelle histoire de coordonnées.

1. Base 3D partagée (utilisez-la partout)

three.js : main droite, +Y vers le haut, les maillages font face +Z, les caméras regardent −Z.

Cap au lacet uniquement sur XZ (véhicules terrestres, marcheurs, la plupart des engins de jeu d'arcade) :

// yaw = 0 fait face au monde −Z ; +yaw est CCW autour de +Y (le nez se déplace vers −X)
forward = (-sin(yaw), 0, -cos(yaw))
right   = ( cos(yaw), 0, -sin(yaw))   // = normalize(cross(forward, worldUp))

Avec une caméra de poursuite derrière l'engin (caméra proche de position - forward * dist) :

Ce que le joueur voitMonde (cette base)Entrée
Nez à gauche+yawA / ← doit produire +yaw (ou l'inclinaison à gauche équivalente pour les avions)
Nez à droite−yawD / → doit produire −yaw

Si votre base diffère, gardez une paire cohérente — mais la ligne visible par le joueur ci-dessus est obligatoire.


2. Cartographies par genre

2a. FPS / à pied (déplacement latéral, pas virage)

W = +forward, S = −forward, D = +right, A = −right   // position, pas lacet
souris : yaw -= movementX * sens ; pitch -= movementY * sens ; clamp pitch

Lacet du corps pour le regard ; le mouvement n'utilise que le lacet (n'appliquez pas le pitch à la marche).

2b. Véhicule terrestre / nautique (kart, moto, jet-ski, bateau, tank, rover, motoneige)

Corps d'arcade avec heading/yaw et vitesse avant speed :

// Entrée (touches maintenues → actions une fois par frame)
let steer = 0 ; // -1..+1, visible par le joueur
if (keys.has('KeyA') || keys.has('ArrowLeft'))  steer += 1 ;  // GAUCHE
if (keys.has('KeyD') || keys.has('ArrowRight')) steer -= 1 ;  // DROITE
// Optionnel : steer = clamp(steer + manetteX, -1, 1) avec même convention de signe

// Intégration (speedFactor ~ 0..1 selon |speed|)
const reverse = speed >= 0 ? 1 : -1 ; // la roue à gauche reste à gauche en marche arrière
yaw += steer * turnRate * speedFactor * reverse * dt ;

// Déplacement le long du cap
const fx = -Math.sin(yaw), fz = -Math.cos(yaw) ;
position.x += fx * speed * dt ;
position.z += fz * speed * dt ;

Bogue canonique (à ne pas copier) :

// FAUX — c'est ce qui livre A/D inversé dans la nature
if (KeyA) steer -= 1 ;
if (KeyD) steer += 1 ;
yaw += steer * turnRate * dt ;  // A → −yaw → nez à DROITE sur caméra de poursuite

Si vous avez déjà écrit KeyA → steer--, soit échangez le mappage des touches, soit annulez une fois à l'intégration (yaw += -steer * …) — puis exécutez §5. Ne faites pas deux inversions (touches + intégration + inclinaison du maillage).

2c. Vol à ailes fixes (avion, planeur, RC)

EntréeActionAttente du joueur
A / ←Roulis à gauche (aileron)Aile gauche basse / inclinaison à gauche
D / →Roulis à droiteAile droite basse / inclinaison à droite
W / ↑Tangage (choisissez un schéma et étiquetez le HUD)Généralement piquer ou cabrer — soyez cohérent
S / ↓Tangage opposé
Q / ELacet / gouverne de direction (optionnel)Q à gauche, E à droite
  • A/D ne sont pas du strafe et pas du « virage au sol avec signes FPS ».
  • Appliquez le roulis dans l' axe avant local de l'engin avec un signe qui correspond à l'inclinaison à gauche sur A. Si le maillage s'incline du mauvais côté, inversez un signe sur l'application du roulis (ou sur le mappage A/D → roulis), pas toute la base.
  • Virage coordonné : une inclinaison positive doit produire un virage qui correspond à la direction de l'inclinaison sous la caméra de poursuite/externe.

2d. Hélicoptère / drone / 6DOF

Documentez le schéma sur une superposition de départ. Minimum :

  • La manette des gaz/l'altitude sur des touches discrètes ne doit pas rester « toujours en haut » après une pression (utilisez un état maintenu ou haut/bas explicite).
  • Déplacement latéral/lacet : A à gauche, D à droite dans le référentiel horizontal de l'engin (visible par le joueur).

2e. Side-scroller / plateforme 2D

D / → se déplace à droite sur l'écran ; A / ← se déplace à gauche. La gravité n'est inversée que si le genre est explicitement sens dessus dessous.


3. La caméra doit être en accord

  • Caméra de poursuite : desired = enginPos + up*height + forward*(-followDist) ; lerp ; lookAt(engin).
  • Calculez forward une fois pour le mouvement et la caméra — ne le reconstruisez pas avec un signe de lacet opposé dans le chemin de la caméra.
  • Ordre de débogage : (1) les touches s'enregistrent → (2) les signes sont corrects (§5) → (3) la caméra est d'accord.

4. Plomberie des entrées (bref)

  • Suivez les touches avec un Set sur keydown/keyup en utilisant event.code ; effacez sur blur / visibilitychange. Déplacez-vous dans la boucle de jeu avec dt, pas dans le gestionnaire de touches.
  • Unifiez clavier + tactile + manette en actions (throttle, steer, pitch, roll, …). Voir building-games/references/input.md.
  • Tactile : stick gauche = déplacement/virage, droite = actions ; cibles de ≥44px.

5. Auto-test de contrôle obligatoire (avant « terminé »)

Une simple capture d'écran ne suffit pas pour tout engin avec A/D.

5a. Liste de contrôle visible par le joueur (chaque construction de véhicule / vol)

Tandis que vous avancez (vitesse > petite epsilon), caméra de poursuite derrière :

MaintenezDoit être observé en ~0,5 s
ALe nez ou l'inclinaison se déplace à gauche sur l'écran
DLe nez ou l'inclinaison se déplace à droite sur l'écran
W (sol)La vitesse augmente / se déplace dans la direction face
S (sol)Freine ou recule (selon la conception)

Si A échoue : inversez le signe de virage/roulis une fois, retestez A et D.

5b. Interface de test minimale (implémentez-la)

Exposez un petit hook pour que vous (et la QA automatisée) puissiez prouver les signes sans deviner les fermetures privées :

// ex. src/game/controlsTest.ts — réservé au développeur/QA

export type ControlsProbe = {
  getYaw: () => number ;       // radians ; ou getHeading()
  getSpeed: () => number ;
  /** Injecte des actions maintenues au lieu de vraies touches ; les deux restent
   *  appliquées jusqu'à ce que vous les changiez, donc §5c peut maintenir une
   *  touche sur plusieurs frames et l'effacer à la fin. */
  setSteer?: (v: number) => void ; // -1..1, même signe qu'en production
  setKeys?: (codes: string[]) => void ; // maintenues jusqu'au prochain appel ; `[]` efface
} ;

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

Câblez window.__controlsTest depuis la boucle de jeu quand import.meta.env.DEV ou un indicateur ?qa=1 est défini.

5c. Vérification automatique (exécutez-la)

Pilotez la sonde §5b avec l'outil préinstallé agent-browser CLI — c'est la première action, pas un script écrit à la main. Un eval qui échoue termine avec un code non nul ; un simple résultat faux ne le fait pas , donc affirmez en lançant une erreur. Exécutez-le en un seul batch — un appel CLI, pas un par verbe — en prenant JSON depuis l'entrée standard ; --bail s'arrête à la première étape en échec et termine avec un code non nul.

agent-browser batch --bail <<'JSON'   # le label de find est sensible à la casse : copiez-le depuis `snapshot -i`
[["open","http://127.0.0.1:8080/"],
 ["find","text","Start","click"],
 ["eval","if (!window.__controlsTest?.setKeys) throw Error('pas de sonde §5b : ajoutez setKeys')"],
 ["eval","__controlsTest.setKeys(['KeyW'])"],
 ["wait","600"],
 ["eval","if (__controlsTest.getSpeed() <= 0.1) throw Error('W : pas de mouvement')"],
 ["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 tourne à DROITE — inversé, obtenu ' + w.toFixed(2)); if (w <= 0.05) throw Error('A a à peine tourné (' + w.toFixed(2) + ') — maintenez plus longtemps ou vérifiez que la simulation tourne'); return 'A ok' })()"],
 ["eval","__controlsTest.setKeys([])"],
 ["screenshot","/workspace/screenshots/controls.png"],
 ["close"]]
JSON

Maintenez les touches via la sonde, pas avec keydown — agent-browser keydown n'atteint pas le Set de §4, donc un jeu correct sera lu comme cassé. Pas de setKeys sur votre sonde ? Ajoutez-la (§5b), ou envoyez vous-même l'événement de touche — la note Keys de la référence de QA navigateur contient le mécanisme et le formulaire.

Le maintien se trouve à l'intérieur d'un seul eval : réparti sur plusieurs commandes, il dure aussi longtemps qu'elles prennent, et l'enveloppe ±π dans Math.atan2(Math.sin(d), Math.cos(d)) lit un engin qui a tourné de plus de π comme s'il tournait dans l'autre sens. L'IIFE est ce qui permet de réexécuter l'étape — un const d = … nu échoue la deuxième fois avec « déjà déclaré » — et async est ce qui permet au maintien de s'exécuter dans le temps de la page. Répétez pour D avec 'KeyD' et les deux comparaisons inversées (w > 0.05 est inversé, w >= -0.05 est à peine), entre guillemets simples pour que le JSON n'ait pas besoin d'échappements ; pour les avions, vérifiez le roulis : A ⇒ inclinaison à gauche.

A tourne à DROITE est l'erreur de signe : inversez un signe et réexécutez. A a à peine tourné ne l'est pas — l'engin a bougé dans la bonne direction, juste moins de 0,05 rad en 300 ms, ce qu'un bateau ou un rover lourd fera ; augmentez la durée de maintien, ou vérifiez que la simulation tourne, et n'inversez rien. Tout autre code de sortie non nul (pas de sonde, démon bloqué) signifie que la vérification n'a jamais été exécutée : lisez le message d'abord. Lisez les liens AGENTS.md de la référence de QA navigateur avant votre premier flux — les verbes, les formes des arguments et le repli s'y trouvent.

5d. Ce qu'il ne faut pas faire

  • Ne pas seulement tester « D augmente une variable interne ».
  • Ne pas utiliser le FPS « D → +X quand on fait face à −Z » comme condition de validation du véhicule.
  • Ne pas inverser l'inclinaison du maillage, la caméra et le virage en même temps lors de la correction — changez un signe, retestez.

6. Critères de fin (contrôles)

  • A ouvert ce skill avant d'écrire du code de mouvement/vol/virage.
  • Cartographie de genre choisie (§2) et les labels de l'écran de démarrage / HUD lui correspondent.
  • Test visible par le joueur de A/D avec caméra de poursuite réussi (§5a).
  • window.__controlsTest (ou équivalent) disponible en dev/QA et utilisé une fois.
  • Aucun maillage incliné inversé par rapport à l'entrée de roulis/virage.
  • Les touches sont en état maintenu + mise à l'échelle par dt ; pas de poussée collante provenant d'un simple tap sur Espace, sauf si intentionnel et étiqueté.

Si une case n'est pas cochée, le jeu n'est pas terminé.

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).

Skills associés