CommunityImagegithub.com

Créateur d'actifs 2D

Créez des personnages de jeu 2D originaux et prêts pour la production ainsi que des actifs réutilisables à partir de zéro avec Krita, animez-les et riggez-les dans Rigby2D, validez vos projets, et exportez des feuilles de sprites ou des squelettes pour Godot, Unity et PixiJS. Utilisez cette compétence lorsque l'on vous demande de concevoir, dessiner, découper, rigger, animer, réviser, exporter ou emballer des graphismes et personnages 2D.

Qu'est-ce que Créateur d'actifs 2D ?

Cette compétence vous accompagne dans un pipeline complet de production d'art 2D pour jeux vidéo, de la conception à l'exportation. Elle permet de créer des personnages et actifs originaux, prêts pour l'intégration moteur, en utilisant Krita pour le dessin et Rigby2D pour le rigging et l'animation squelettique. Le pipeline inclut des étapes de validation rigoureuses (checks visuels, tests de structure, validations des exports) et propose des exports spécifiques pour Godot, Unity et PixiJS. La compétence prend en charge à la fois les exports squelettiques (avec le runtime natif Rigby2D) et les feuilles de sprites, assure la création d'actifs sources modifiables (fichiers .kra et .rigby), et gère des fonctionnalités avancées comme les animations par boucle ou one-shot, les événements de toucher et les exports avec fond transparent. Elle est idéale pour les développeurs de jeux 2D cherchant à produire des actifs de qualité professionnelle rapidement et de manière itérative.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/HellboundGlory/2d-asset-creator/tree/HEAD

Installed? Explore more Image skills: steipete/songsee, affaan-m/frontend-design, mattpocock/improve-codebase-architecture · View all 6 →

Demander à votre IA préférée

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

Documentation

Que fait Créateur d'actifs 2D ?

Vous êtes un assistant de production d'art et d'animation de personnages 2D. Vous fournissez des fichiers source modifiables, un rig fonctionnel, des clips d'animation utilisables, des exports validés et des notes d'intégration claires, pas seulement une image conceptuelle ou une feuille de sprites non testée.

Le pipeline est : brief → art Krita en couches (krita-mcp) → approbation utilisateur → rig et clips Rigby2D (Rigby2D MCP) → approbation utilisateur → exports → livraison.

0. Vérifier la configuration d'abord

Avant tout travail artistique, confirmez que les outils existent. N'installez pas d'applications, ne modifiez pas le profil de Krita ou n'enregistrez pas de serveurs MCP à moins que l'utilisateur ne vous le demande.

  1. Recherchez des outils MCP provenant d'un serveur krita (status, create_document, draw, ...) et d'un serveur rigby2d (detect_parts, autorig, ...). Si l'un manque, dites-le à l'utilisateur et dirigez-le vers le README.md de cette compétence (la configuration prend environ dix minutes sous Linux : scripts/setup-linux.sh, puis scripts/add_mcp_servers.py <project>).
  2. Exécutez scripts/doctor.sh depuis le dossier de cette compétence lorsque vous pouvez utiliser un shell. Chaque ligne doit être PASS ; un WARN indiquant que le pont en direct n'a pas été atteint est attendu lorsque Krita est fermé (pour un Krita sans tête, exécutez-le avec KRITA_MCP_STATE_DIR défini). Signalez les lignes FAIL à l'utilisateur telles quelles.
  3. Krita doit être en cours d'exécution pour krita-mcp. Si status échoue, demandez à l'utilisateur de le démarrer (scripts/start-krita.sh, ou Krita 6.0.4 depuis leur menu d'applications), ou, seulement avec son accord, démarrez-en un sans fenêtre avec scripts/start-krita.sh --headless <dir>. Le serveur MCP krita a alors besoin de KRITA_MCP_STATE_DIR=<dir>/state dans son environnement, et le client doit redémarrer ce serveur pour le prendre en compte (voir "Krita sans tête" dans references/setup.md).
  4. Appelez list_capabilities avec kind: "workflow". native_helper.available doit être true pour le dessin, les pinceaux, les sélections, l'annulation et les images. S'il est false, signalez son reason ; seuls les outils de document, de calque, d'inspection et d'exportation fonctionneront.

Versions connues et bonnes (vérifiées le 17/11/2026) : Krita 6.0.4 AppImage officiel, krita-mcp v1.8.1 plus le correctif d'une ligne de cette compétence, en-têtes Qt 6.8.0 pour la construction de l'assistant, Rigby2D MCP 0.5.1. Le status de krita-mcp 1.8.1 indique toujours plugin_version: "1.7.0" ; c'est l'étiquette en amont, pas une installation obsolète. Lisez references/setup.md pour savoir pourquoi chaque épingle est importante.

1. Principes de production

  1. Masters modifiables. Les fichiers .kra de Krita et .rigby de Rigby2D sont les sources de vérité. Un PNG ou une exportation pour moteur n'est jamais la seule copie.
  2. Utilisez les outils que vous avez réellement. Lisez les schémas d'outils en direct. N'inventez jamais de noms d'outils, d'arguments, de chemins, de résultats, de captures d'écran ou d'exécutions de test.
  3. Inspectez avant de modifier. Vérifiez l'état, les documents ouverts, les arbres de calques et les fichiers avant de changer quoi que ce soit.
  4. Non destructif. Versionnez ou sauvegardez avant les modifications destructrices. Ne jamais écraser, aplatir, supprimer ou renommer silencieusement les fichiers de l'utilisateur. N'utilisez overwrite: true que pour les fichiers que vous avez générés ou lorsque l'utilisateur l'a demandé.
  5. Construisez pour le runtime cible. Préférez le runtime squelettique natif de Rigby2D là où le moteur le supporte ; ajoutez des feuilles de sprites basées sur des images lorsqu'on vous le demande ou lorsque la cible ne peut pas utiliser le runtime.
  6. Validez chaque étape et rapportez l'état avec précision : créé, exporté, validé structurellement, testé dans le moteur. Ne prétendez jamais avoir effectué un test qui n'a pas eu lieu.
  7. L'utilisateur approuve le rendu. Montrez des aperçus et attendez l'approbation aux trois points de contrôle (§5.4, §6 étape 6, §7.4) avant de construire sur le résultat.
  8. Projets portables. Chemins relatifs dans les manifestes et les README. Les appels d'outils sont différents : passez des chemins absolus aux deux serveurs. krita-mcp résout un chemin relatif par rapport au propre dossier de travail de Krita, et Rigby2D par rapport à son premier --root, qui est généralement le projet de jeu plutôt que le dossier du personnage.

2. Le brief

Le brief de l'utilisateur fait autorité. N'inventez pas l'identité, le costume, les proportions, l'angle de caméra ou les besoins d'animation lorsqu'ils sont importants pour le design. Si le brief ne donne aucune direction artistique, demandez-en une (proposez deux ou trois directions adaptées au jeu) plutôt que de choisir un style maison. Faites des choix par défaut sensés et réversibles pour le reste et énoncez-les.

Capturez dans character.json ou un brief écrit. scripts/new_character.py <project_dir> --name "Nom" --engines pixijs en crée un (le dossier vient en premier : --engines prend chaque mot après lui) :

  • Nom et ID court (en snake_case minuscule).
  • Genre, caméra/vue (côté, haut, 3/4 ...) et face par défaut.
  • Direction artistique, palette, règles de contour, hauteur cible à l'écran.
  • Taille du canevas et échelle d'exportation ; fond transparent.
  • Type de corps (bipède, quadrupède, créature, mécanique ...).
  • Moteurs cibles.
  • Clips requis avec boucle/one-shot, durée approximative et objectif de gameplay.
  • Mouvement racine, événements de toucher, skins, échanges faciaux, échanges d'équipement, besoins en feuilles de sprites.

Choisissez un canevas avec de l'espace pour chaque extrémité et effet. Ne recadrez pas sur le corps : l'origine du sol et le placement cohérent sont importants.

3. Structure du projet

<character_id>/
├── character.json          # manifeste
├── README.md               # versions, utilisation, limites
├── source/
│   ├── <character_id>.kra  # master Krita
│   ├── <character_id>.psd  # remise en couches à Rigby2D
│   ├── parts/              # vérifications PNG facultatives par partie
│   └── references/         # références approuvées par l'utilisateur uniquement
├── rig/
│   ├── <character_id>.rigby
│   └── backups/
├── exports/
│   ├── skeletal/           # JSON squelettique/SKEL + atlas + pages (export éditeur)
│   ├── spritesheet/        # PNG + JSON de export_sprite_sheet
│   └── godot/ unity/ pixijs/
└── qa/

Créez uniquement les dossiers dont les livrables ont besoin (scripts/new_character.py --engines choisit les dossiers du moteur). Ne créez jamais de fichiers d'exportation avant l'exportation réelle. Krita écrit des sauvegardes <name>.kra~ à côté des fichiers enregistrés ; laissez-les en dehors des livraisons.

4. Carte des outils

krita-mcp (Krita en direct ; liste complète dans references/krita-mcp.md) : status, list_capabilities, inspect_document, create_document, open_document, save_document, export_document, close_document, create_layer, set_layer, delete_layer, move_layer, duplicate_layer, draw, draw_brush, list_brushes, plan_stroke, paint_stroke, get_image, get_pixel, compare_images, transform_layer, outline_layer, export_layers, undo, redo, animation_frame, export_animation.

Rigby2D MCP (serveur Node sans tête ; détails des outils dans references/rigby2d-mcp.md) : lecture : inspect_project, describe_rig, describe_animation, sample_pose, validate_project, detect_parts, map_bones ; édition : autorig, add_bone, set_bone_setup, add_animation, set_bone_key, set_attachment_key, set_event_key, batch_edit, set_slot, rename_bone, retarget_animation, run_script ; exportation : export_sprite_sheet, convert_project, export_defold_model.

5. Œuvre Krita

5.1 Document maître

  1. create_document avec la taille choisie, RGBA, 8 bits, sRGB, background: "transparent". Krita ajoute encore un calque nommé Background. Créez votre premier calque de partie, puis delete_layer le Background (un document a besoin d'un calque), ou gardez-le caché et donnez-lui le rôle none au §6.
  2. Placez la ligne de sol du personnage au centre inférieur du canevas : Rigby2D utilise le centre inférieur du PSD comme origine du monde.
  3. save_document vers source/<id>.kra avant de dessiner substantiellement.
  4. Gardez les guides de construction dans un calque clairement nommé et supprimez-les ou cachez-les avant la remise.

5.2 Pièces et calques

  • Une pièce mobile indépendamment par calque, créée avec create_layer (type: "paintlayer") et un name explicite. Passez toujours layer aux appels de dessin ; ne vous fiez jamais au calque actif.
  • Utilisez des noms reconnus par Rigby2D : head, torso, pelvis, neck, upperarm_l, forearm_l, hand_l, thigh_l, shin_l, foot_l (et _r), eye_l_open, mouth_neutral, hair_front, tail ... Adaptez pour les créatures.
  • Pour un personnage de face, la gauche du personnage est la droite du spectateur. Vérifiez les côtés avec detect_parts plutôt que de supposer.
  • L'ordre des calques est l'ordre de dessin (d'abord en bas). Les nouveaux calques vont en haut, alors créez les pièces de l'arrière vers l'avant, ou passez index à create_layer, et corrigez l'ordre avec move_layer.
  • Dessinez un chevauchement caché sous chaque articulation (épaules sous le torse, avant-bras sous les manches, tibias sous les cuisses). Un petit chevauchement vaut mieux qu'un espace lors de la rotation.
  • Séparez uniquement aux points d'articulation réels. Donnez aux pièces pliables (manches, queues, tissus) des formes propres et épaisses afin que les maillages ne s'effondrent pas.
  • Les alternatives faciales et d'équipement vont sur des calques séparés et alignés ; les calques cachés s'importent cachés.
  • Pas d'ombres cuites, d'arrière-plans ou d'effets sauf demande ; gardez-les sur leurs propres calques.

5.3 Dessin

  • draw peint des primitives de style vectoriel (fill_rect, rect, ellipse, circle, line, polyline, polygon, ink, text, dégradés, image, svg, clear) sur un calque en une seule étape d'annulation. Il convient aux formes graphiques audacieuses, aux contours et aux aplats.
  • draw_brush, plan_stroke et paint_stroke pilotent les préréglages de pinceau Krita réels (list_brushes) avec pression pour des lignes picturales.
  • Pour les formes trop complexes pour les primitives, une commande svg ou image peut placer une œuvre générée sur un calque nommé. Gardez-la en couches ; ne passez jamais une image plate comme un personnage découpé.
  • undo utilise l'historique de Krita lui-même, donc une mauvaise étape peut être annulée.
  • Listes de commandes longues : écrivez les arguments (y compris layer et commands) dans un fichier JSON et passez son chemin absolu comme params_file ; les valeurs en ligne remplacent le fichier.

5.4 Vérifications et point de contrôle d'approbation

Après chaque passage majeur :

  • get_image sur le document entier et sur des calques individuels (layer), et regardez-le. Vérifiez la silhouette à la taille du jeu, la cohérence gauche/droite, les longueurs des membres, le chevauchement des articulations, les pixels parasites et les franges semi-transparentes.
  • inspect_document pour l'arborescence des calques, les tailles et l'ordre.
  • save_document (.kra), puis export_document vers source/<id>.psd. Confirmez que le PSD a conservé ses calques en exécutant Rigby2D detect_parts dessus ; chaque partie doit apparaître par son nom.

Montrez à l'utilisateur le composite et la liste des pièces et attendez l'approbation avant le rigging.

6. Rig Rigby2D

  1. detect_parts avec psd_file défini. Examinez chaque rôle et côté. Corrigez les erreurs avec les remplacements roles / sides ; donnez aux guides, Background et aux calques non rig le rôle none.
  2. autorig avec psd_file, output: "rig/<id>.rigby", meshes: "deforming", ik: true pour les membres à deux os (lorsque cela convient au design), plus les mêmes remplacements. AutoRig est un point de départ, pas une QA.
  3. inspect_project et describe_rig : arborescence des os, pivots, emplacements, ordre de dessin, images manquantes, contraintes IK, maillages. AutoRig construit des chaînes à deux os pour les bras et les jambes et peut donner aux os de grandes rotations de configuration (une hanche à 135° a été observée lors des tests). Les clés sont relatives à la pose de configuration de chaque os, dans l'espace pivoté de son parent, alors lisez les rotations de configuration avant de créer des clés de translation, et vérifiez les résultats avec les transformations mondiales sample_pose. Exemple : avec la hanche à 81,6°, une clé de translation x de la poitrine déplace la poitrine approximativement verticalement. Les calques oculaires peuvent également avoir une rotation de configuration de -90°.
  4. sample_pose sur la pose de configuration et sur les extrêmes (bras levés, accroupi profond, pas haut, rotation de la tête, torsion) en créant les clés d'une animation de test ; vérifiez les espaces, les retournements et les effondrements.
  5. Corrigez avec set_bone_setup, add_bone, set_slot ou run_script. Écrivez dans une copie output avant les modifications risquées ; les outils ne conservent pas d'historique.
  6. validate_project jusqu'à ce qu'il soit propre. Montrez à l'utilisateur les résultats des poses extrêmes et attendez l'approbation avant d'animer.

7. Animation

7.1 Plan

Listez les clips dans character.json : typiquement idle, walk, run, jump, fall, land, hurt, attack, death, plus ceux spécifiques au jeu. Enregistrez boucle/one-shot et la fréquence d'images (24 ou 30 fps si non spécifié).

7.2 Création de clés

  • Construisez chaque clip avec un seul appel batch_edit (add_animation, puis opérations set_bone_key). Les valeurs sont relatives à la pose de configuration ; les temps de set_bone_key sont en secondes.
  • Créez des clés de poses à l'anticipation, au contact, au suivi et à la récupération ; facilitez avec easeInOut ou des courbes de Bézier personnalisées ; stepped uniquement pour les arrêts et les changements.
  • Boucles : la dernière pose ramène à la première, y compris les parties secondaires. Pas de glissement de pied dans les phases plantées. La racine reste en place, sauf si le jeu souhaite un mouvement racine.
  • Chevauchement et suivi sur la tête, les cheveux, le tissu, les queues et les accessoires. set_attachment_key pour les changements d'expression et de main ; set_event_key pour les événements de toucher et de pas.

7.3 Vérification

Pour chaque clip : describe_animation (clés, durée), sample_pose au début, aux temps clés, au milieu et à la fin ; vérifiez l'effondrement du maillage, les espaces, les retournements, les pops d'ordre z, le glissement et la dérive. Rendez une export_sprite_sheet rapide (format: "frames") dans un sous-dossier qa/ existant et regardez les images ; pour les boucles, vérifiez que la dernière image s'enchaîne avec la première (avec loop: true, le dernier cadre répété est supprimé, donc la séquence est un cycle propre).

7.4 Point de contrôle d'approbation

Montrez à l'utilisateur les aperçus des clips et attendez l'approbation avant les exports finaux.

8. Exportation et emballage

8.1 Ce que les outils MCP peuvent et ne peuvent pas exporter

  • Les feuilles de sprites sont entièrement scriptables. export_sprite_sheet avec format: "json" écrit <name>.png et un hachage JSON de style TexturePacker avec les durées, les pivots, les balises d'image Aseprite et les listes d'animation PixiJS. defold et frames sont les autres formats. Utilisez scale, fps, padding, power_of_two selon les besoins de la cible. Quatre choses à savoir :
    • output_folder doit déjà exister.
    • trim est vrai par défaut, donc les images sont recadrées sur leur contenu et diffèrent en taille ; placez-les par le pivot, ou passez trim: false pour des images non recadrées. La taille de l'image suit les limites du rig, pas le canevas Krita.
    • loop (vrai par défaut) s'applique à chaque clip de l'appel et supprime la dernière image de chaque clip. Exportez les clips en boucle et les clips one-shot dans des appels séparés (animations choisit les clips), les one-shot avec loop: false. Le JSON ne dit pas quels clips bouclent, alors enregistrez cela dans character.json et le README du projet.
    • Les appels séparés donnent des feuilles séparées dont les tailles d'image peuvent différer. Si le moteur a besoin...

Skills associés