Communitygithub.com

evalix098/tiktoklive

Créez des jeux de navigateur, des expériences interactives/canvas/3D dans cette application TanStack Start + React. Idéal pour tout jeu, simulation ou expérience WebGL/Canvas – 2D ou 3D, en solo. Couvre la boucle de jeu et le timing, les conventions d'orientation/caméra 3D, la collision, les performances, les assets, l'audio, la sauvegarde, le "game feel" et des guides par genre. Pour les signes d'entrée WASD/volant/vol et l'inversion A/D, ouvrez la compétence **`controls`** – ne vous fiez pas à ce fichier ou à racing-kart seul.

Qu'est-ce que tiktoklive ?

Cette compétence fournit un guide complet pour construire des jeux de navigateur jouables et corrects, en se concentrant sur la boucle de jeu et la gestion du monde. Elle est conçue pour être utilisée avec des applications React utilisant TanStack Start, et supporte à la fois les rendus 2D (Canvas natif) et 3D (three.js, @react-three/fiber). Le document détaille les aspects critiques comme le calcul du delta time, le scaling de la vitesse par frame, le cap du delta pour éviter les téléportations, et l'utilisation d'un pas de temps fixe pour la physique. Il insiste fortement sur la délégation de la gestion des contrôles (WASD, volant, vol) à la compétence `controls` dédiée, afin d'éviter les bugs d'inversion courants. Enfin, il couvre les conventions 3D (orientation des maillages, des caméras), les règles de performance (minimisation des draw calls, nettoyage des ressources GPU), la création d'assets (3D versus 2D, utilisation des compétences spécialisées comme `game-asset-core`), et les critères de finition (pas d'erreur console, tests de la compétence `controls`, build de production, carte de partage X).

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

Demander à votre IA préférée

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

Documentation

Créer des jeux

Créez un jeu de navigateur jouable et correct – pas une capture d'écran statique. Un jeu est simplement une route React avec un <canvas> (ou <Canvas> pour R3F) et une interface DOM superposée. Stylisez la superposition (écran d'accueil, HUD, menus) avec la compétence design-ui ; cette compétence gère la boucle de jeu et le monde.

Contrôles / A/D inversé : ouvrez .grok/skills/controls/SKILL.md avant d'écrire du code WASD, de direction ou de vol. Les démos de véhicules/vol livrent souvent un A/D inversé si vous lisez uniquement ce fichier ou un seul guide de genre.

Note de périmètre – solo, bots ou coop P2P à petite échelle :

  • Livrez solo ou solo + IA/bots par défaut.
  • Coopération 2–8 joueurs / temps réel décontracté (curseurs partagés, jeux de groupe, action décontractée entre amis) est prise en charge – utilisez la compétence multiplayer-p2p (maillage WebRTC, signalé via /api/rtc). Lisez d'abord son modèle de confiance.
  • P2P est le seul multijoueur pris en charge pour l'instant. Ne construisez pas à moitié des sockets qui ne peuvent pas se connecter.

Références (chargement à la demande) :

  • Compétence controls (../controls/) – obligatoire pour les déplacements/volant/vol : A/D visible par le joueur, anti-modèle du volant inversé, ailerons de vol, auto-test obligatoire + window.__controlsTest. Non facultatif pour les véhicules/avions.
  • references/threejs-foundational.md – la référence approfondie 3D/boucle/perf. À lire pour la 3D.
  • references/3d-libs.md – utilisation de three.js + @react-three/fiber + drei + rapier.
  • Compétence threejs (../threejs/) – dump officiel complet de l'API Three.js + TSL (llms-full.txt). À charger pour les matériaux/shaders/WebGPU/loaders avancés ; pas pour les jeux 2D simples.
  • references/babylon.md – Babylon.js, l'alternative de moteur 3D tout-en-un.
  • references/phaser.md – Phaser 3, le moteur par défaut pour les jeux 2D.
  • references/ecs-architecture.md – architecture de système de composants d'entités pour les jeux plus volumineux.
  • references/genres/*.md – guides par genre (fps, platformer-2d, racing-kart, puzzle-match3-tetris, voxel-minecraft, endless-runner, topdown-twin-stick, tower-defense, board-card-chess). Les fichiers de genre ne remplacent pas controls.
  • references/game-feel-juice.md, input.md, audio.md, collision-physics.md, save-persistence.md, procedural-generation.md, ai-pathfinding.md.
  • game-asset-core (+ game-animation-frames / game-tilesets / game-character-consistency / game-ui-icons) – valeurs par défaut et vérification d'art 2D prêt pour le moteur lors de la génération de sprites, feuilles, tuiles ou UI (voir §6).

Choisissez la référence de genre/sujet spécifique pour la construction ; ce fichier est le noyau universel pour la boucle/monde. Signes d'entrée → controls. Art de jeu 2D → game-asset-core.


1. Boucle de jeu et timing (le problème de correction n°1)

  • Pilotez la boucle avec la boucle RAF du moteur (renderer.setAnimationLoop, useFrame de R3F ou requestAnimationFrame pour Canvas 2D). Jamais setInterval/setTimeout/Date.now() pour le timing du jeu.
  • Mettez à l'échelle TOUT déplacement/animation par le delta time (secondes) afin que la vitesse soit indépendante de la fréquence d'images (60 Hz vs 144 Hz). Calculez le delta une fois par image et réutilisez-le.
    • three.js : utilisez THREE.Timer (pas Clock – Clock.getDelta() renvoie ~0 lors d'un second appel dans la même image, un bug de freeze classique).
  • Limitez le delta (min(delta, 0.1)) pour qu'un onglet en arrière-plan ne téléporte pas les objets.
  • Pas de temps fixe pour la physique/le gameplay : accumulez le delta et exécutez la simulation à un taux fixe (par exemple 1/60) tout en rendant au taux d'affichage – empêche le tunneling et la non-déterminisme.

2. Contrôles (déléguez à la compétence controls)

Ouvrez .grok/skills/controls/SKILL.md avant d'implémenter tout code WASD / volant / vol. Cette compétence est la source de vérité pour :

  • A = gauche / D = droite visible par le joueur (caméra de poursuite, en avançant)
  • Pourquoi KeyA → steer− + yaw += steer * +rate inverse (le bug le plus courant)
  • Véhicule vs FPS (strafe ≠ volant), ailerons d'avion à voilure fixe, notes pour hélico/drone
  • Auto-test obligatoire + sonde window.__controlsTest

Ne traitez pas genres/racing-kart.md comme le seul endroit où vivent les signes de volant – les avions, jet-skis et mechs ne l'ouvrent jamais.

Rappel court (détails complets dans controls) :

// Lacet du corps du véhicule (caméra de poursuite) : A doit augmenter le lacet avec cette base
forward = (-sin(yaw), 0, -cos(yaw))
// KeyA → steer = +1 ;  yaw += steer * turnRate * speedFactor * dt
// FAUX (livre inversé) : KeyA → steer = -1 ; yaw += steer * turnRate * dt
  • Verrouillage du pointeur : regard à la souris uniquement – implémentez WASD vous-même ; superposition clic-pour-jouer ; fermez au verrouillage.
  • Suivez les touches avec l'état maintenu + dt ; unifiez les périphériques via references/input.md.
  • Terminez : exécutez la liste de vérification de la compétence controls. Une simple capture d'écran est insuffisante pour les véhicules/vol.

3. Orientation 3D et objets du monde (les bugs "de côté/à l'envers")

  • three.js est pour droitiers, +Y vers le haut : +X droite, +Y haut, +Z vers le spectateur. Les maillages font face à +Z ; les caméras regardent −Z (l'erreur classique "caméra à l'envers").
  • Les primitives comme Cone/Cylinder pointent +Y par défaut → tournez pour aligner une pointe vers l'avant (geo.rotateX(Math.PI/2)).
  • Orienter un maillage pour faire face à forward (les maillages font face à +Z) : la manière correcte la plus simple est mesh.lookAt(mesh.position.clone().add(forward)). Pour construire la base à la main, définissez la colonne +Z sur forward et choisissez l'axe x qui maintient une rotation correcte pour droitiers (det = +1) : xAxis = normalize(cross(up, forward)), puis makeBasis(xAxis, up, forward). Notez qu'il s'agit de cross(up, forward) – pas du right = cross(forward, up) de déplacement du §2. Cibler +Z (au lieu du −Z d'une caméra) inverse le signe de l'axe x de sorte que xAxis × up = forward ; le repère reste pour droitiers (sans miroir). N'utilisez pas makeBasis(xAxis, up, -forward) pour un maillage – cela cible -forward (la convention caméra) donc le maillage fait face à l'envers.
  • Orienter une caméra pour regarder le long de forward (les caméras regardent −Z) : définissez la colonne +Z sur -forward – xAxis = normalize(cross(forward, up)), puis makeBasis(xAxis, up, -forward) (ou simplement camera.lookAt(target)).
  • Gardez un up de monde cohérent pour que les objets restent droits ; ne faites pivoter que les primitives plates pour les mettre debout.
  • Vérifiez l'orientation d'importation glTF ; déboguez avec AxesHelper/ArrowHelper. Auto-test de redressement : les personnages se tiennent sur le plan de sol, pas couchés/enfoncés.

4. La caméra doit être en accord avec le mouvement

  • Gardez un moveForward/moveRight dédié pour le mouvement, calculé une fois et jamais modifié par le code de la caméra (l'aliasing d'un vecteur temporaire partagé fait que la caméra et le mouvement ne sont pas d'accord – un vrai bug reproductible).
  • Suivi à la troisième personne : desired = playerPos + up*height + moveForward*(-followDist) ; interpolez la caméra vers elle (utilisez un lissage expo, mis à l'échelle du delta), lookAt(player).
  • Ordre de débogage isolez-la-couche : (1) les touches s'enregistrent → (2) les signes de mouvement sont corrects → (3) la caméra est d'accord. Corrigez dans cet ordre.

5. Performances

  • Minimisez les appels de tirage (renderer.info.render.calls, ciblez <100) : partagez les matériaux, InstancedMesh/BatchedMesh pour les objets répétés, atlas.
  • Libérez vous-même les ressources GPU (geometry/material/texture.dispose()) lors des changements de niveau – three.js ne les nettoie pas. Mettez en pool les balles/ennemis/particules.
  • Pas d'allocations par image (réutilisez les vecteurs temporaires). Compressez les textures ; LOD pour la distance.

6. Assets (évitez le piège de la photo générée)

  • Éléments 3D interactifs (modèles d'armes, personnages, accessoires, projectiles) → construisez à partir de géométrie 3D / glTF, pas d'une image générée. Un JPG photoréaliste plat d'une arme dans les mains utilisé comme modèle d'arme FPS a l'air faux, ne peut pas être animé et (le JPG n'a pas d'alpha) rend une boîte noire. Rattachez un vrai modèle 3D à la caméra en tant que couche de rendu superposée.
  • Réservez la génération d'images aux assets 2D plats uniquement (textures, arrière-plans de ciel/menus, sprites 2D, art UI). N'utilisez jamais une photo générée comme maillage 3D, modèle d'arme ou substitut de personnage – construisez-les en géométrie 3D / glTF. Définissez crossOrigin="anonymous" sur les images dessinées sur canvas/textures. Voir la compétence imagine-grok-build (2D uniquement – les outils d'image ne peuvent pas produire de vraie 3D).
  • Doctrine d'art de jeu prêt pour le moteur → ouvrez game-asset-core (../game-asset-core/) pour les valeurs par défaut + vérification aveugle + discipline de nouvelle tentative, puis le spécialiste correspondant : game-animation-frames (lois de boucle/mouvement), game-tilesets, game-character-consistency, game-ui-icons. Ce sont des doctrines QC, pas le pipeline d'exportation. Ne livrez pas de placeholders en bâtons alors que du vrai art est attendu.
  • Sprites 2D de jeu / feuilles d'animation → exécutez generate2dsprite (.grok/skills/generate2dsprite/SKILL.md) : feuilles magenta #FF00FF solides imagine_text_to_image + scripts de post-traitement chroma (le magenta est requis pour le processeur). Intégrez des PNG/GIF transparents dans Canvas/Phaser. Appliquez toujours game-asset-core (+ les spécialistes animation/personnage le cas échéant).
  • Cartes 2D / niveaux / packs d'accessoires → ouvrez generate2dmap (.grok/skills/generate2dmap/SKILL.md). Préférez une base uniquement fondamentale + des accessoires/collision séparés pour des cartes jouables. Par défaut navigateur : raw_canvas / Phaser. Sols/murs carrelables → aussi game-tilesets pour les vérifications de coutures 2×2.
  • Locomotion plus dense optionnelle → exécutez video2dsprite (Grok imagine_image_to_video + scripts sandbox ; base magenta). Préférez generate2dsprite pour des héros de production nets. Utilisez game-animation-frames pour les lois de boucle/test de retournement ; préférez video2dsprite à une récolte ad-hoc ffmpeg uniquement dans ce sandbox.

7. Audio, sauvegarde, "game feel"

  • Audio : déverrouillez AudioContext sur le premier geste utilisateur (tap-pour-démarrer) sinon iOS reste silencieux ; reprenez sur visibilitychange. (references/audio.md)
  • Sauvegarde : localStorage/IndexedDB avec un champ version + migrations.
  • Jus : tremblement d'écran, arrêt-sur-image, tweens fluides, particules – peu coûteux, énorme amélioration de qualité perçue. Gardez la présentation séparée de la simulation.

8. Mobile

  • Distinguez la taille du buffer canvas de la taille CSS ; respectez devicePixelRatio.
  • touch-action: none, letterbox-fit à une résolution de base, gérez l'orientation.
  • Contrôles tactiles (joystick virtuel + boutons d'action), cibles ≥44px.

Choix de la pile / moteur

  • 3D → three.js, idéalement via @react-three/fiber + drei (s'intègre à l'app React ; drei fournit verrouillage du pointeur/contrôles/chargeurs) + @react-three/rapier pour la physique/contrôleurs de personnage. Voir references/3d-libs.md.
  • 2D → Le Canvas 2D natif suffit pour snake/tetris/flappy/platformer ; utilisez Phaser uniquement lorsque le genre le nécessite.
  • Ces dépendances de jeu ne sont pas préinstallées – installez-les avec npm install (et assurez-vous qu'elles atterrissent dans package.json pour que le build Vercel les ait).

Critères de finition (avant "terminé")

  • Se charge sans erreurs console ; gameplay visible (pas un canvas vide).
  • Auto-test de la compétence controls réussi (A = gauche / D = droite depuis la caméra de poursuite en avançant ; inversez un signe si inversé). Pas seulement une capture d'écran.
  • Auto-tests de redressement 3D et d'accord de caméra réussis (§3, §4).
  • Fonctionne sur la fenêtre mobile avec des contrôles tactiles.
  • Le build de production (npm run build) rend le résultat construit, pas seulement le développement.
  • Carte de partage / X : ouvrez la compétence og – public/og.jpg personnalisée et "type": "x:game" dans src/lib/og/site.json. X utilise og:type="x:game" pour présenter le déploiement sous forme de carte de jeu ; n'utilisez pas twitter:card ou n'inventez pas x:type pour cela. browser-smoke / brand-check avertissent lorsque les applications canvas omettent le champ site.json.

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

Player-facing input signs for browser games: WASD, vehicles, flight, FPS mouse-look, and the #1 failure mode (inverted A/D). Mandatory control self-tests and a tiny test interface so you can verify A turns left before shipping. Load for ANY game with movement, steering, flying, driving, tanks, boats, mechs, drones, planes, karts, third-person follow cams — not only racing. Triggers on "controls", "WASD", "inverted", "steer", "flight", "airplane", "kart", "vehicle", "yaw", "roll", "pitch", "mouse look", "A/D".

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