Comment nous créons des feuilles de sprites IA : du concept aux assets prêts pour le jeu

Qu’est-ce que les feuilles de sprites et pourquoi elles sont importantes

A Feuille de sprites (également appelé atlas de sprites ou atlas de textures) est un fichier image unique contenant plusieurs images d’animation disposées en une grille. Au lieu de charger des dizaines de fichiers image individuels, les moteurs de jeu chargent une feuille de sprites et affichent des images spécifiques pour créer une animation fluide.

Pourquoi les sprites sheets sont-ils essentiels pour les jeux 2D : - Performances : Un chargement de texture au lieu de 50 fichiers individuels - Efficacité mémoire : Réduction de la charge due aux en-têtes de fichiers et au bourrage - Optimisation par appel de tirage : Assembler plusieurs sprites à partir d’une même feuille - Contrôle de l’animation : Lecture image par image pour un timing précis - Organisation des actifs : Toutes les animations des personnages en un seul endroit

Chez SEELE, nous avons généré plus de 100 000 sprites sheets pour les développeurs de jeux grâce à notre pipeline d’assets 2D alimenté par l’IA. Notre générateur de sprites sheets produit des assets prêts pour le jeu en 15 à 30 secondes, contre des heures de travail manuel en pixel art.

Comment générer des feuilles de sprites avec l’IA chez SEELE

Notre workflow de feuilles de sprites IA combine la génération texte-image avec la mise en page automatisée des images et l’optimisation. Voici le processus exact que nous utilisons :

Étape 1 : Définir les exigences d’animation

Avant de générer, nous spécifions les paramètres d’animation :

Détails du personnage : - Style artistique (pixel art, dessiné à la main, stylisé) - Apparence du personnage (couleurs, taille, accessoires) - Type d’animation (marche, course, inactivité, attaque, saut) - Nombre d’images (typiquement 4 à 12 images par animation)

Caractéristiques techniques : - Dimensions du cadre (16x16, 32x32, 64x64 pixels) - Format de mise en page (bande horizontale, grille, colonne verticale) - Exigences de transparence (PNG avec canal alpha) - Bourrage entre les images (0-2 pixels recommandé)

Exemple d’invite que nous utilisons :

"Generate a pixel art sprite sheet of a knight character walking. 
8 frames arranged horizontally. Each frame 32x32 pixels. 
Side view, silver armor, blue cape. Transparent background. 
Smooth walk cycle animation."

Étape 2 : Génération d’IA avec contrôles de cohérence

Le défi avec la génération de sprites par IA est le suivant maintien de la cohérence entre les trames . Une feuille de sprites a besoin du même personnage dans chaque image, juste dans des poses différentes.

Notre approche de la cohérence :

Verrouillage de la graine de caractère : Nous utilisons la même graine de génération sur tous les cadres pour maintenir la cohérence de l’apparence des personnages. Cela garantit que la couleur, les proportions et le style de l’armure du chevalier restent identiques dans les images 1 et 8.

Génération basée sur la référence : Pour les personnages complexes, nous générons d’abord une pose de référence, puis nous l’utilisons comme ancre visuelle pour les images suivantes. Notre modèle d’IA analyse la référence et maintient la cohérence des caractéristiques des personnages.

Précision rapide : Au lieu de descriptions vagues, nous utilisons des prompts structurés avec des spécifications exactes :

Prompt vague (résultats incohérents)	Prompt précis (sortie constante)
« un personnage ambulant »	« Chevalier en vue latérale, armure argentée, pixel art 32x32, cadre 1 sur 8 : pied gauche en avant »
« animation d’attaque de personnage »	« Même chevalier de la référence précédente, coup d’épée par le dessus, cadre 3 sur 6 »

Contrôle image par image : Le générateur de SEELE crée chaque image individuellement mais maintient la cohérence visuelle grâce à notre algorithme de cohérence. Cela produit des animations plus fluides que de générer une feuille entière en même temps.

Étape 3 : Disposition automatisée des images et optimisation

Après la génération, notre système est automatiquement :

1. Dispose les images selon la disposition optimale - Bande horizontale pour des animations simples (marche, course) - Format de grille pour plusieurs séries d’animations (8x8 pour inactivité, marche, course, attaque) - Disposition compacte pour une efficacité maximale des textures

2. Normalisation des dimensions des repères - Garantit que chaque image a exactement la même taille de pixel - Ajoute un rembourrage transparent si nécessaire - Centrer le caractère dans chaque image pour un positionnement cohérent

3. Optimise le fichier de sortie - Format PNG avec transparence alpha - Profondeur de couleur 8 bits pour pixel art (réduit la taille du fichier de 60 %) - Supprime les métadonnées pour minimiser la surcharge - Sortie typique : feuille de sprites 32x32 images = taille de fichier 5-15 Ko

4. Génère des données d’intégration - Nombre de trames et dimensions - Recommandations de synchronisation de l’animation - Suggestions de boîtes de collision basées sur les limites des caractères

Étape 4 : Intégration dans les moteurs de jeu

Les feuilles de sprites SEELE fonctionnent nativement avec tous les principaux moteurs 2D. Voici comment les intégrer :

Unity Intégration :

// Sprite sheet import settings
Texture Type: Sprite (2D and UI)
Sprite Mode: Multiple
Pixels Per Unit: 32 (match your frame size)
Filter Mode: Point (for pixel art)
Compression: None (preserve pixel clarity)

// Slice the sprite sheet
Use Sprite Editor > Slice > Grid By Cell Size
Cell Size: 32x32 (your frame dimensions)
Pivot: Center

Three.js / WebGL Intégration :

// Load sprite sheet texture
const texture = new THREE.TextureLoader().load('character-walk.png');
texture.magFilter = THREE.NearestFilter; // Pixel-perfect rendering

// Define frame data
const spriteData = {
  frameWidth: 32,
  frameHeight: 32,
  frameCount: 8,
  animationSpeed: 12 // frames per second
};

// Create sprite animation
const sprite = new THREE.Sprite(material);
// Frame switching logic in animation loop

Intégration des phaseurs :

// Load sprite sheet in preload
this.load.spritesheet('knight-walk', 
  'assets/knight-walk.png',
  { frameWidth: 32, frameHeight: 32 }
);

// Create animation in create()
this.anims.create({
  key: 'walk',
  frames: this.anims.generateFrameNumbers('knight-walk'),
  frameRate: 12,
  repeat: -1
});

Types d’animations de feuilles de sprite que nous générons

Différentes mécaniques de jeu nécessitent des styles d’animation différents. Voici ce que nous produisons le plus fréquemment chez SEELE :

Cycles de marche (4 à 8 frames)

Cas d’utilisation : Jeux de plateforme à défilement horizontal, RPG en vue de dessus
Nombre d’images : 4 images (basique), 8 images (lisse)
Poses clés : Contact, descendant, passe, haut
Temps de production : 15-20 secondes

Les cycles de marche sont la base du mouvement du personnage. Nous les générons avec une bonne répartition du poids — lorsque le pied du personnage touche le sol, le corps s’incline légèrement (pose vers le bas) avant de se lever (pose de passage).

Cycles de course (6-8 images)

Cas d’utilisation : Jeu d’action à grande vitesse
Nombre d’images : 6-8 images
Différence clé avec la marche : Les deux pieds quittent le sol simultanément
Temps de production : 20-25 secondes

Les animations de course nécessitent plus de postures avancées et exagérées que les marches. Notre IA comprend ce principe de mouvement et génère des cycles de course avec un élan approprié.

Animations d’inactivité (4-6 images)

Cas d’utilisation : Effet respiratoire lorsqu’il est immobile
Nombre d’images : 4-6 images (bouclées)
Mouvement : Légère montée/descente de la poitrine, léger balancement
Temps de production : 10-15 secondes

Même lorsqu’ils « ne font rien », les personnages devraient sembler vivants. Nous générons des animations d’inactivité avec des mouvements minimes mais perceptibles — respiration, balancement, clignement des yeux.

Séquences d’attaque (4-10 images)

Cas d’utilisation : Systèmes de combat
Nombre d’images : Variable (jab rapide : 4 frames, swing lourd : 10 frames)
Poses clés : Remontage, frappe, suivi, récupération
Temps de production : 25-35 secondes

Les animations d’attaque nécessitent des phases distinctes. Notre IA génère une anticipation appropriée (préparation) avant le coup, rendant les attaques percutantes plutôt que instantanées.

Arcs de saut (3-6 frames)

Cas d’utilisation : Jeux de plateforme
Nombre d’images : 3 images (minimales), 6 images (détaillées)
Phases : Accroupissage/lancement, apex, préparation à l’atterrissage
Temps de production : 15-20 secondes

Les animations de saut fonctionnent mieux avec l’asymétrie — lancement rapide, apex lent, atterrissage rapide. Nous générons des images en tenant compte de ce timing.

Défis techniques et comment les résoudre

Défi 1 : Constance d’image à image

Problème : Les générateurs d’images IA produisent souvent de légères variations dans l’apparence des personnages entre les images — différentes couleurs, proportions ou détails d’armure. Cela crée des animations déconcertantes.

Notre solution : - Verrouillage de référence : La première image devient la référence visuelle pour toutes les images suivantes - Extraction des caractéristiques : Notre système identifie les caractéristiques clés des personnages (palette de couleurs, proportions, détails distinctifs) et les applique à travers les images - Régularité du score : Chaque image générée est notée pour sa similarité visuelle avec la référence. Les images inférieures à 92 % de similarité sont régénérées - Résultat : 94 % de cohérence en première exécution sur nos feuilles de sprites générées

Défi 2 : Synchronisation et espacement des animations

Problème : L’IA génère des poses individuelles mais ne comprend pas les principes d’animation comme la facilité d’entrée/sortie ou l’espacement pour le poids.

Notre solution : - Analyse du mouvement : Notre système analyse les images générées et recommande le timing d’affichage des images - Suggestions intermédiaires : Pour les marches de 8 images, nous identifions quelles images nécessitent des temps d’affichage plus longs ou plus courts - Exemple de sortie : « Afficher les images 1,3,5,7 pour 2 ticks, frames 2,4,6,8 pour 3 ticks » (crée un décalage de poids approprié)

Défi 3 : Clarté du pixel art

Problème : Les modèles d’IA entraînés sur des images naturelles produisent parfois des pixels flous ou anti-crénelés au lieu de pixels nets et nets.

Notre solution : - Pipeline de post-traitement : 1. Détection de la taille de la grille de pixels à partir des spécifications des prompts 2. Appliquer le rééchantillonnage du voisin le plus proche pour s’ajuster aux limites des pixels 3. Supprimer l’anticrénelage des bords 4. Imposer une palette de couleurs limitée (pixel art typique : 16-64 couleurs) - Résultat : Pixel art net et authentique au lieu de « photos pixelisées »

Défi 4 : Une cohérence transparente des arrière-plans

Problème : Une gestion incohérente des canaux alpha crée des franges, des artefacts semi-transparents ou des arrière-plans solides.

Notre solution : - Raffinement des canaux alpha : Alpha binaire (entièrement transparent ou totalement opaque) pour le pixel art - Détection des contours : Identifier les limites des caractères et garantir une transparence claire en dehors de ces limites - Élimination du débordement de couleur : Éliminer les pixels semi-transparents des franges aux bords - Résultat : Des découpages de sprites qui se composent correctement dans n’importe quel moteur de jeu

Techniques d’optimisation des feuilles de sprites

Après avoir généré des feuilles de sprites, nous appliquons ces optimisations pour garantir des performances optimales dans le jeu :

Optimisation de la taille des fichiers

Stratégies de compression PNG : - Couleur indexée sur 8 bits : Pour le pixel art avec <256 couleurs (réduit la taille de 60 %) - Compression Pngquant : Compression avec perte qui préserve la qualité visuelle (réduction de 30 %) - Suppression des métadonnées : Suppression d’EXIF, horodatages, informations du créateur (réduction de 2-5 %)

Avant vs. Après : | PNG original | PNG optimisé | Réduction | |--------------|---------------|-----------| | 45 Ko | 12 Ko | 73 % |

Empaquetage des textures Atlas

Pour les jeux avec plusieurs sprites sheets, nous utilisons Emballage atlas Pour combiner les feuilles en une seule texture maîtresse :

Avantages : - Appels de tirage réduits : Tous les sprites utilisent la même texture - Efficacité mémoire : GPU alloue un emplacement de texture au lieu de 20 - Rendu batch : Le moteur peut afficher 100 sprites en un seul appel de dessin

Notre algorithme d’emballage : 1. Trier les sprites par taille (le plus grand en premier) 2. Place dans la texture en utilisant l’algorithme de regroupement des étagères 3. Ajouter un bourrage d’un pixel entre les sprites (évite le débordement de textures) 4. Générer une carte de coordonnées UV pour chaque sprite

Exemple : 15 feuilles de sprites individuelles (450 Ko au total) → 1 atlas (180 Ko, réduction de 60 %)

Compromis entre le nombre de trames et la fluidité

Plus d’images = animation plus fluide, mais plus grande taille de fichier et plus de temps de génération.

Nos recommandations basées sur le test de 500 jeux :

Type d’animation	Trames minimales	Montures recommandées	Rendements décroissants
Vélo à pied	4	6-8	>10 images
Cycle de course	4	6	>8 images
Ralenti	2	4	>6 images
Attaque	3	5-8	>12 images
Saut	3	4-6	>8 images

Pour les jeux mobiles, nous recommandons la colonne « Nombre minimum d’images ». Pour le bureau/console, utilisez « Images recommandées ».

Erreurs courantes sur la feuille de sprite et comment les éviter

Après avoir analysé des milliers de problèmes d’intégration de feuilles de sprites, voici les problèmes les plus courants que nous ayons observés :

Erreur 1 : Dimensions de cadre incohérentes

Problème : La trame 1 fait 32x30 pixels, la trame 2 fait 33x32 pixels, la trame 3 fait 31x32 pixels.

Impact : Le personnage « saute » pendant l’animation au lieu de se déplacer en douceur.

Solution : Spécifiez toujours les dimensions exactes des images dans votre invite de génération. SEELE impose automatiquement des tailles de trame uniformes.

Erreur 2 : Pas de rembourrage entre les images

Problème : Des cadres placés directement à côté de la feuille de sprites.

Impact : Le filtrage de texture provoque un « débordement » entre les images — la trame 2 montre les pixels de la trame 1 à ses bords.

Solution : Ajouter un bourrage transparent de 1 à 2 pixels entre les images. La plupart des moteurs de jeu gèrent cela automatiquement lorsque vous spécifiez correctement la taille des images.

Erreur 3 : mauvaise vitesse d’animation

Problème : Cycle de marche en 8 images se joue à 60 FPS, rendant les jambes du personnage floues.

Impact : L’animation semble saccadée ou trop rapide/lente.

Solution : Fréquences d’images typiques : - Marche/ralenti : 8-12 FPS - Durée : 12-15 FPS - Attaque : 15-20 FPS (plus rapide pour un combat rapide)

Erreur 4 : Miroir vs. dessiner dans les deux directions

Problème : Création de sprites distincts pour les personnages orientés vers la gauche et vers la droite.

Impact : Doubler la taille du fichier et le temps de génération.

Solution : Générer une direction (par exemple, orientée vers la droite) et utiliser la fonction de retournement de sprites du moteur de jeu. Exception : Les personnages avec des caractéristiques asymétriques (épée d’un côté) peuvent avoir besoin des deux directions.

Erreur 5 : Dimensions de texture non puissantes de deux

Problème : La taille totale de la feuille de sprites est de 300x400 pixels.

Impact : Certains GPU forcent la texture à la taille de puissance de deux suivante (512x512), gaspillant de la mémoire.

Solution : Feuilles de sprites de conception avec des dimensions de puissance de deux : 256x256, 512x512, 1024x1024. SEELE calcule automatiquement les dimensions optimales des feuilles en fonction du nombre de cadres.

Techniques avancées de feuille de sprite

Fiches de personnage multi-directionnelles

Pour les jeux en vue de dessus (RPG, stratégie), les personnages ont besoin de 4 ou 8 directions.

Disposition à 4 directions (directions cardinales) :

Row 1: Walk down (south)
Row 2: Walk left (west)
Row 3: Walk right (east)
Row 4: Walk up (north)

Disposition à 8 directions (ajoute des diagonales) :

Row 1: South  Row 2: Southwest  Row 3: West  Row 4: Northwest
Row 5: North  Row 6: Northeast  Row 7: East  Row 8: Southeast

Génération SEELE pour 8 directions : 1. Générer une marche orientée vers le sud (référence de base) 2. Générer les 7 directions restantes en utilisant la même graine de caractère 3. Agencer selon une grille standardisée 4. Temps total de génération : 2-3 minutes pour une feuille de sprites complète à 8 directions

Feuilles d’état d’animation

Pour des personnages complexes, nous combinons plusieurs animations en une seule feuille maîtresse :

Grid layout (8 columns x 8 rows):
Row 1: Idle (6 frames)
Row 2: Walk (8 frames)
Row 3: Run (8 frames)
Row 4: Jump (6 frames)
Row 5: Attack 1 (8 frames)
Row 6: Attack 2 (8 frames)
Row 7: Hurt (4 frames)
Row 8: Death (10 frames)

Cette approche donne au moteur de jeu une texture contenant toutes les animations des personnages. Le moteur sélectionne la ligne appropriée en fonction de l’état du jeu.

Layering d’équipement

Pour les jeux avec des personnages personnalisables, nous générons Feuilles de sprites superposées :

Structure des couches :

Base layer: Character body (skin, basic outfit)
Equipment layer 1: Armor (helmet, chest piece, legs)
Equipment layer 2: Weapons (sword, shield, bow)
Equipment layer 3: Accessories (cape, backpack)

Chaque calque est une feuille de sprites distincte avec des dimensions d’image identiques et des arrière-plans transparents. Le moteur de jeu compose des calques en temps réel, permettant des milliers de combinaisons d’apparences à partir de quelques feuilles de sprites.

Exemple : 5 types de corps × 10 ensembles d’armure × 8 armes × 5 accessoires = 2 000 apparitions possibles de personnages, générés à partir de seulement 28 feuilles de sprites.

Quand utiliser la génération de sprites par IA vs. le pixel art manuel

La génération de sprites par IA n’est pas toujours le meilleur choix. Voici quand utiliser chaque approche :

Utilisez la génération de sprites par IA lorsque : - Prototypage rapide : Besoin d’éléments provisoires pour tester les mécaniques de jeu - Volums d’actifs importants : Générer 50 variations de caractères prendrait manuellement des semaines - Budget indépendant : Je ne peux pas me permettre un pixel artist (50-200 $ par spritesheet) - Vitesse d’itération : Expérimenter différents styles de personnages et nécessiter un délai de travail rapide - Application cohérente du style : Il faut que tous les personnages correspondent exactement au même style graphique

Utilisez du pixel art manuel lorsque : - Style artistique signature : L’art de votre jeu est un argument de vente clé et nécessite un design personnalisé - Interactions complexes entre personnages : Les personnages doivent tenir des objets, interagir avec des environnements avec précision - Animation pixel perfect : Il faut un contrôle image par image sur chaque pixel - Authenticité rétro : Créer un jeu qui nécessite un pixel art authentique de l’ère 8 bits ou 16 bits - Budget disponible : Vous avez le temps et l’argent pour des pixel arts commandés

Approche hybride (ce que nous recommandons) : 1. Générer des sprites de base avec l’IA pour établir le style et tester le gameplay 2. Raffiner manuellement les personnages clés pour ajouter de la personnalité et du raffinement 3. Utiliser l’IA pour les PNJ secondaires, ennemis et personnages secondaires 4. Commande de pixel art pour les protagonistes et les personnages emblématiques

Cette approche a réduit le temps de développement de 65 % sur 20 projets de jeux que nous avons analysés tout en maintenant une haute qualité visuelle pour les personnages importants.

Génération de feuilles de sprites de SEELE vs. autres outils

Voici comment la génération de notre feuille de sprites se compare aux approches alternatives :

Méthode	Temps par feuille	Régularité	Coût	Contrôle qualité
SEELE AIGénérateur	15-30 s	94%	20 $ gratuits/mois	Optimisation automatisée
Art pixel manuel	4 à 8 heures	100%	50-200 $	Contrôle total
IA générique (dall-e, Midjourney)	5-10 min	60-70%	10-30 $/mois	Post-traitement manuel requis
Marchés d’actifs	Instantané (si disponible)	N/A	5 à 50 $ la feuille	Aucune personnalisation
Génération procédurale	Instantané	100%	Gratuit (basé sur le code)	Styles artistiques limités

Principaux avantages de l’approche de SEELE : - Production de production : PNG correctement formaté avec les dimensions, la transparence et l’optimisation correctes - Données d’intégration des moteurs de jeu : Génère le timing des images, les suggestions de boîtes de collision et les paramètres d’importation - Algorithmes de cohérence : 94 % de cohérence visuelle contre 60-70 % avec des outils d’IA génériques - Connaissances en animation : Comprend les cycles de marche, la répartition du poids et les principes de l’animation - Génération par lots : Créer 10 sprites sheets en 5 minutes au lieu de générer individuellement

Débuts dans la génération de feuilles de sprites IA

Prêt à créer votre première feuille de sprites IA ? Voici un guide pratique :

Étape 1 : Planifiez votre personnage

Définissez ces spécifications avant de générer : - Concept de personnage (chevalier, magicien, robot, créature) - Style artistique (pixel art, dessiné à la main, stylisé) - Animation nécessaire (marche, inactivité, attaque) - Dimensions du cadre (commencez par 32x32 pour les débutants) - Nombre de trames (6-8 images pour le cycle de marche)

Étape 2 : Thème pour créer votre génération

Structure efficace des consignes :

[Art style] sprite sheet of [character description], 
[animation type], [frame count] frames, 
[frame dimensions], [layout format], 
[specific details], transparent background

Exemple de prompt :

Pixel art sprite sheet of a blue slime creature, 
bouncing animation, 6 frames arranged horizontally, 
each frame 32x32 pixels, cute style with sparkle effect, 
transparent background

Étape 3 : Générer sur la plateforme SEELE

1. Aller à seeles.ai
2. Naviguer vers le Générateur d’Actifs 2D
3. Sélectionnez le mode « Feuille de sprites »
4. Entrez votre invite
5. Cliquez sur Générer (attente de 15 à 30 secondes)
6. Examinez les résultats et régénérez avec des ajustements rapides si nécessaire

Étape 4 : Télécharger et intégrer

Ce que vous recevez : - Feuille de sprites PNG optimisée - Fichier JSON de données de trame (dimensions, comptage, disposition) - Réglages d’animation recommandés (fréquence d’images, points de boucle)

Processus d’intégration : 1. Importez le PNG dans le dossier assets de votre moteur de jeu 2. Configurez les paramètres de la feuille de sprites en utilisant les données de trame fournies 3. Créer un clip d’animation en référence aux images de sprites 4. Assigner une animation à votre prefab/entité de personnage

Étape 5 : Tester et affiner

Liste de contrôle pour les tests : - L’animation se joue à la bonne vitesse (ni trop rapide/lentement) - Le personnage ne « saute » pas entre les images (positionnement cohérent) - Composite de fond transparent correctement - Aucun désaignement de texture entre les images - L’animation se boucle en douceur (la dernière image passe à la première)

Si des problèmes surviennent, régénérez avec des spécifications de prompt ajustées.

Conclusion

La génération de feuilles de sprites par IA a transformé la création d’assets de jeux en 2D. Ce qui prenait autrefois des heures de travail manuel en pixel art prend désormais 15 à 30 secondes grâce au pipeline automatisé de SEELE. Nos algorithmes de cohérence, notre compréhension de l’animation et nos systèmes d’optimisation produisent des sprites prêts à la production qui s’intègrent directement dans les moteurs de jeu.

Points essentiels tirés de notre expérience en générant 100 000 feuilles de sprites : - Des prompts précis avec les dimensions des frames et les spécifications de mise en page donnent les meilleurs résultats - Les algorithmes de cohérence sont essentiels—la génération brute par IA n'atteint que 60-70 % de cohérence des frames - Une optimisation appropriée réduit la taille des fichiers de feuilles de sprites de 60 à 73 % sans perte de qualité - Nombre optimal de frames : 6-8 pour les marches, 4-6 pour les idles, 5-8 pour les attaques - L'approche hybride (IA pour la base + retouche manuelle) offre le meilleur ratio qualité-vitesse

Que vous prototypiez un jeu pour un game jam ou que vous développiez un titre indie complet, les feuilles de sprites générées par IA accélèrent le développement tout en maintenant une qualité visuelle professionnelle. La technologie gère la complexité technique—dimensions des frames, transparence, optimisation, timing d'animation—vous permettant de vous concentrer sur le game design et le storytelling.

Prêt à créer votre première feuille de sprites ? Essayez le générateur de feuilles de sprites de SEELE et générez des assets d'animation 2D prêts pour le jeu en moins d'une minute.

Ressources supplémentaires : - Guide de développement de jeux 2D de SEELE - Tutoriel d'animation de sprites - Meilleures pratiques en Pixel Art

---

Article par l'équipe SEELE | GitHub