Communitygithub.com

evalix098/tiktoklive

Grok Build uniquement. Transformez une image fixe de personnage 2D en sprites d'animation denses via imagine_text_to_image → imagine_image_to_video (6s/10s sur place) → ffmpeg frames → incrustation magenta → bandes/grilles/GIFs denses. À utiliser lorsque l'utilisateur souhaite des sprites vidéo, des cycles de marche/course plus fluides ou des poses intermédiaires plus denses. Préférez generate2dsprite pour des feuilles de pixels de production nettes. Se déclenche sur "video to sprite", "imagine_image_to_video sprite", "dense walk cycle", "smooth run animation from video".

Qu'est-ce que tiktoklive ?

Cette compétence transforme une image fixe d'un personnage 2D en sprites d'animation denses, exclusivement dans l'environnement Grok Build. Le processus commence par la génération d'une image de base (via imagine_text_to_image) ou l'utilisation d'une image existante, suivie d'une animation vidéo sur place (imagine_image_to_video) de 6 ou 10 secondes. Les images sont ensuite extraites, nettoyées par incrustation magenta (fond #FF00FF), et échantillonnées pour produire des bandes, grilles et GIFs denses (8, 16, 24 ou 48 trames). L'utilisateur peut contrôler l'action (course, marche, repos, attaque), la durée, le nombre de trames, et la taille des cellules. Cette compétence est idéale pour créer des cycles de mouvement plus fluides que les poses discrètes, mais produit des pixels plus doux et une dérive d'identité ; pour des feuilles de sprites de production nettes, il est conseillé d'utiliser generate2dsprite. Elle ne fonctionne que sur Grok Build et nécessite un outil de transformation image→vidéo.

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

Demander à votre IA préférée

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

Documentation

Video2dsprite (Grok Build uniquement)

Convertissez une image de personnage 2D de base en sprites d'animation denses à l'aide des outils vidéo natifs de Grok Build.

Environnement App-builder / Grok

ÉlémentValeur
Répertoire de la compétence.grok/skills/video2dsprite/
Scriptspython3 .grok/skills/video2dsprite/scripts/video2dsprite.py …
Outils vidéoimagine_image_to_video — anime un file_path de base (vérifier la présence)
Inspectionread_file sur les images fixes/trames ; rapporter les chemins des vidéos
Dépendancesffmpeg + Pillow + numpy (préinstallés dans l'image app-builder)
Dossier de sortieassets/sprites/video2dsprite/<name>/ sous /workspace
Par défautPréférer generate2dsprite pour les héros de production ; il s'agit ici du chemin de mouvement dense
image fixe de base → imagine_image_to_video (mouvement sur place) → extraire les trames → incrustation → échantillonnage/normalisation → bande / grille / GIF

Vérification de la plateforme (à lire en premier)

ExécutionPrise en charge ?
Grok Build (xAI)Oui — nécessite un générateur d'image + un outil image→vidéo
Codex / Claude / autres agentsNon — ils ne disposent pas des outils vidéo Grok. Informez l'utilisateur que cette compétence est réservée à Grok Build et proposez $generate2dsprite à la place

Vérifiez la capacité, pas le nom exact de l'outil. La génération d'image apparaît sous imagine_text_to_image / imagine_image_to_image ; la vidéo sous imagine_image_to_video ou (héritage) generate_video. Utilisez la paire présente dans votre liste d'outils. Arrêtez-vous et expliquez uniquement lorsque vous n'avez aucun outil image→vidéo. Ne simulez pas le mouvement avec des trames dessinées par code.

Cette compétence est un chemin optionnel de mouvement dense. Elle ne remplace pas $generate2dsprite :

Utilisez $generate2dsprite lorsque…Utilisez $video2dsprite lorsque…
Feuilles de pixels nettes, grilles fixes, héros à identité critiqueL'utilisateur souhaite des poses intermédiaires plus denses / des boucles plus fluides
Feuilles de corps d'attaque/de lancer, packs d'accessoires, atlas de moteurExpérimente avec un mouvement de course/marche/repos issu de vidéo
Par défaut de production pour la plupart des sprites de jeuL'utilisateur demande explicitement vidéo → trames → sprites

La vidéo adoucit les pixels, fait dériver l'identité et laisse des franges d'incrustation. Toujours effectuer un contrôle de qualité ; pour les héros de production, préférez $generate2dsprite sauf si l'utilisateur souhaite l'aspect vidéo.

Paramètres

Déduire de la demande de l'utilisateur :

  • subject : description du personnage / créature, ou chemin d'une image fixe existante
  • action : run | walk | idle | attack | phrase de mouvement personnalisée
  • view : généralement side (side-scroller). topdown est plus difficile — avertir et maintenir la caméra fixe
  • duration : 6 (par défaut) ou 10 secondes
  • frame_counts : ensembles denses à exporter, par défaut 8,16,24,48
  • cell_size : taille de la cellule de sprite de sortie, par défaut 128
  • anchor : feet (par défaut pour la locomotion latérale) | center
  • bg : #FF00FF solide (obligatoire pour l'incrustation)
  • name : slug de sortie
  • out_dir : dossier de travail (par défaut ./sprites/video2dsprite/<name>/ ou relatif au projet)

Règles pour l'agent

  1. Réservé à Grok. Refuser sur les exécutions non-Grok avec une brève explication + alternative $generate2dsprite.
  2. Image fixe → vidéo, jamais texte→vidéo seul. Préparer l'image 1 comme une image fixe nette avec imagine_text_to_image (à partir d'une invite, ou d'un file_path de référence). Puis appeler imagine_image_to_video avec le file_path de cette image fixe.
  3. Mouvement sur place. Suggérer une course/marche sur place face à une direction fixe. Pas de panoramique, pas de défilement d'arrière-plan, pas de changement de scène. Le sujet reste à peu près centré.
  4. Fond magenta solide sur l'image de base et conservé dans l'invite vidéo (#FF00FF / magenta pur). Obligatoire pour l'incrustation par remplissage par zone.
  5. Ne pas inventer d'art avec PIL/Canvas. L'art de base provient de imagine_text_to_image ou d'une image fixe utilisateur/locale. Les scripts ne font que du post-traitement.
  6. Ne pas placer les sorties expérimentales dans le jeu sauf si l'utilisateur demande l'intégration.
  7. Préférer un cycle de locomotion pour une utilisation dans un jeu. Un échantillonnage dense sur un clip complet de 6s multi-cycles convient pour les aperçus ; pour les feuilles de moteur, ré-échantillonner éventuellement un seul cycle (12–16 trames) après un contrôle de qualité visuel.
  8. Signaler les chemins absolus de la vidéo, des trames nettoyées, des bandes et des GIFs d'aperçu une fois terminé.

Flux de travail

1. Planification

Choisir le plus petit ensemble utile :

  • Boucle de course/marche vue de côté → cette compétence
  • Kit de héros multi-actions → utiliser encore $generate2dsprite par action ; utiliser la vidéo uniquement pour la locomotion si demandé
  • FX / projectiles / packs d'accessoires → $generate2dsprite, pas la vidéo

Créer :

<out_dir>/
  base/
  video/
  frames-raw/
  frames-clean/
  sprite/          # ensemble par défaut de 8 trames + plus dense x16/x24/x48
  prompt-used.txt
  pipeline-meta.json
  README.txt

2. Construire l'image fixe de base

Options :

  • A. Sprite existant : lire l'image, la composer sur un fond #FF00FF solide si nécessaire, puis passer ce chemin sandbox à imagine_image_to_image / imagine_image_to_video
  • B. Nouveau personnage : imagine_text_to_image avec fond magenta solide, corps entier, vue de côté, centré
  • C. Correspondre à une référence : imagine_image_to_image avec le file_path de référence, le déplacer sur magenta et préserver l'identité

Exigences de base :

  • Corps entier visible, marge magenta généreuse
  • Vue de côté pour la course/marche (profil ou 3/4), pieds près du tiers inférieur
  • Même style artistique que le reste du projet lorsqu'une référence existe
  • Pas de texte, d'interface, de filigrane ou de second personnage

Copier le file_path renvoyé et l'enregistrer sous <out_dir>/base/<name>-base.png ; conserver le file_path de base pour l'appel vidéo.

Écrire l'invite exacte de l'image dans prompt-used.txt.

3. Animer avec imagine_image_to_video

Appeler Grok imagine_image_to_video :

  • chemin source : <file_path de l'image fixe de base> (chemin sandbox renvoyé par T2I / I2I)
  • duration : 6 (par défaut) ou 10
  • resolution_name : 480p sauf si l'utilisateur demande 720p
  • prompt : un court plan au présent (voir references/prompt-rules.md)

Contraintes de mouvement obligatoires dans l'invite :

  • Le sujet court/marche sur place (style tapis roulant)
  • Caméra verrouillée — pas de panoramique, zoom ou orbite
  • L'arrière-plan reste plat magenta solide
  • Identité, costume, palette stables pendant tout le plan
  • Action unique et continue uniquement

Copier le file_path vidéo renvoyé vers <out_dir>/video/<name>-<duration>s.mp4.

Si les outils vidéo ne sont pas disponibles, s'arrêter (vérification de la plateforme).

4. Extraction + incrustation + échantillonnage (script local)

Exécuter le processeur (ffmpeg + Pillow + numpy) :

python3 .grok/skills/video2dsprite/scripts/video2dsprite.py process \
  --video <out_dir>/video/<name>-6s.mp4 \
  --out-dir <out_dir> \
  --name <name> \
  --frame-counts 8,16,24,48 \
  --cell-size 128 \
  --body-height 100 \
  --foot-y 118 \
  --fps 0

Remarques :

  • --fps 0 = extraire chaque trame décodée (utiliser le fps source)
  • Remplissage magenta par zone à partir des coins + suppression de l'incrustation
  • Échantillonnage uniforme pour chaque nombre dans --frame-counts
  • Cellules normalisées aux pieds, bande horizontale, grille, GIF en boucle par nombre

Optionnel : ré-échantillonner uniquement les ensembles plus denses à partir des trames nettoyées existantes :

python3 .grok/skills/video2dsprite/scripts/video2dsprite.py sample \
  --clean-dir <out_dir>/frames-clean \
  --out-dir <out_dir> \
  --frame-counts 16,24,48 \
  --cell-size 128

5. Contrôle de qualité

Vérifier visuellement :

  • Les GIFs d'aperçu bouclent sans sauts importants
  • Magenta disparu (pas de blocs roses solides) ; les franges sont acceptables ou une nouvelle incrustation est nécessaire
  • Les pieds restent sur une ligne de base stable (pas de saut dû à un mauvais recadrage)
  • Identité à peu près stable (visage/vêtements ne se transforment pas à chaque trame)
  • L'action est sur place (ne glisse pas hors du cadre)
  • Pour une utilisation dans un jeu : choisir un nombre (souvent 16 ou 24) ou couper un vrai cycle

Si l'identité dérive fortement ou si les pixels sont trop doux, revenir à $generate2dsprite pour les feuilles de production et conserver l'ensemble vidéo uniquement comme référence de mouvement.

6. Livraison

Signaler uniquement les chemins (sauf si l'utilisateur demande une intégration dans un jeu) :

  • Vidéo : video/*.mp4
  • Sprites denses : sprite/x16|x24|x48/
  • Bandes / grilles / GIFs : sprite/run-strip-N.png, run-grid-N.png, run-preview-N.gif
  • Métadonnées : pipeline-meta.json

Ne pas modifier le code du jeu sauf demande.

Valeurs par défaut

  • Durée : 6s
  • Action : course latérale sur place, face à droite
  • Nombres d'exportation : 8, 16, 24, 48
  • Cellule : 128², hauteur du corps ~100, pieds à y≈118
  • Fond : #FF00FF
  • Préférer imagine_image_to_video mono-actif plutôt que multi-références (composer multi-références avec imagine_text_to_image d'abord si nécessaire)

Compromis (informer l'utilisateur une fois)

Avantages : intermédiaires plus denses → souvent plus fluide que 4 à 8 poses générées discrètement.
Inconvénients : pixels plus doux, dérive d'identité, franges d'incrustation, clips de 6s multi-cycles ne sont pas une seule boucle parfaite, ressources plus lourdes.
Règle empirique : 8→16→24 gagne généralement en fluidité ; 48 a souvent des rendements décroissants ; 145 trames brutes sont pour l'échantillonnage, pas toutes pour l'exécution.

Ressources

Relations avec les autres compétences

  • $generate2dsprite — pipeline principal de feuilles (Codex + Grok lorsque la génération d'image existe)
  • $generate2dmap — cartes ; non utilisé ici
  • $video2dsprite — chemin exclusif à Grok Build de densification du mouvement
  • $game-asset-core / $game-animation-frames — boucle/test de retournement/lois du mouvement et valeurs par défaut prêtes pour le moteur ; utiliser encore les scripts de cette compétence pour l'exécution en sandbox (base magenta + incrustation), pas une couleur de fond libre

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

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

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