Compétences unity-ecs-patterns
📦

unity-ecs-patterns

Sûr

Implémenter les modèles Unity ECS

Créer des jeux Unity haute performance nécessite des modèles orientés données spécialisés que la POO traditionnelle ne peut pas fournir. Cette compétence fournit des modèles ECS prêts pour la production utilisant DOTS, Jobs et Burst pour des jeux qui évoluent vers des milliers d'entités.

Prend en charge: Claude Codex Code(CC)
📊 69 Adéquat
1

Télécharger le ZIP du skill

2

Importer dans Claude

Allez dans Paramètres → Capacités → Skills → Importer un skill

3

Activez et commencez à utiliser

Tester

Utilisation de "unity-ecs-patterns". Create an ECS component for player health with current and max values, and a system that heals players over time.

Résultat attendu:

  • Définition du composant :
  • ```csharp
  • public struct Health : IComponentData
  • {
  • public float Current;
  • public float Max;
  • }
  • ```
  •  
  • Système de guérison :
  • ```csharp
  • [BurstCompile]
  • public partial struct HealthRegenSystem : ISystem
  • {
  • public void OnUpdate(ref SystemState state)
  • {
  • float deltaTime = SystemAPI.Time.DeltaTime;
  • float regenRate = 5f;
  •  
  • foreach (var health in
  • SystemAPI.Query<RefRW<Health>>())
  • {
  • health.ValueRW.Current = math.min(
  • health.ValueRO.Max,
  • health.ValueRO.Current + regenRate * deltaTime
  • );
  • }
  • }
  • }
  • ```

Utilisation de "unity-ecs-patterns". How do I convert a GameObject to an entity with authoring?

Résultat attendu:

  • 1. Créer un MonoBehaviour d'authoring :
  • ```csharp
  • public class EnemyAuthoring : MonoBehaviour
  • {
  • public float Speed;
  • public float Health;
  •  
  • class Baker : Baker<EnemyAuthoring>
  • {
  • public override void Bake(EnemyAuthoring authoring)
  • {
  • var entity = GetEntity(TransformUsageFlags.Dynamic);
  • AddComponent(entity, new Speed { Value = authoring.Speed });
  • AddComponent(entity, new Health { Current = authoring.Health, Max = authoring.Health });
  • }
  • }
  • }
  • ```
  •  
  • 2. Ajouter le composant d'authoring à un GameObject dans l'éditeur
  • 3. Le système de baking le convertit automatiquement en entité au moment de la compilation

Utilisation de "unity-ecs-patterns". Write a parallel job that damages all enemies in a radius around each entity.

Résultat attendu:

Cela nécessite une approche par hachage spatial. D'abord, construire une carte de hachage spatial dans un job parallèle. Ensuite, exécuter un second passage qui interroge les cellules voisines et applique les dégâts. La fonction de hachage spatial utilise la multiplication par nombres premiers pour une distribution uniforme : `hash = x * 73856093 ^ y * 19349663 ^ z * 83492791`.

Audit de sécurité

Sûr
v5 • 1/21/2026

All 59 static findings are false positives. The skill contains Unity ECS documentation with code examples. Detected patterns (hash functions, system API references, backticks) are legitimate game development patterns and Markdown formatting, not security threats.

2
Fichiers analysés
1,194
Lignes analysées
0
résultats
5
Total des audits
Aucun problème de sécurité trouvé

Score de qualité

38
Architecture
100
Maintenabilité
87
Contenu
22
Communauté
100
Sécurité
87
Conformité aux spécifications

Ce que vous pouvez construire

Développeur de jeux indépendants créant des jeux critiques en performance

Créer des systèmes de jeu efficaces qui gèrent des milliers d'ennemis, de particules ou d'unités sans dégradation des performances en utilisant des modèles ECS.

Programmeur gameplay apprenant DOTS

Passer des modèles traditionnels Unity MonoBehaviour à l'architecture ECS orientée données avec des exemples guidés et des bonnes pratiques.

Artiste technique créant des systèmes de particules

Créer des systèmes de particules et d'effets massifs qui se traitent en parallèle en utilisant Jobs et la compilation Burst pour des performances de type GPU sur CPU.

Essayez ces prompts

Composant ECS de base
Create a Speed component and a MovementSystem in Unity ECS using ISystem and BurstCompile. The system should move entities forward based on their speed value.
Système de génération d'entités
Write a SpawnSystem that uses EntityCommandBuffer to create entities at runtime with a Spawner component. Include both single-threaded and parallel job versions.
Personnage basé sur les aspects
Create a CharacterAspect that groups Health, Speed, and LocalTransform components. Include a method to apply damage that respects shield absorption logic.
Système de hachage spatial
Build a spatial hashing system using NativeParallelMultiHashMap for efficient collision queries. Include the hash function and parallel job for updating the spatial grid.

Bonnes pratiques

  • Utiliser ISystem au lieu de SystemBase pour des performances maximales et la compatibilité Burst
  • Toujours appliquer [BurstCompile] aux jobs et systèmes pour des performances optimales
  • Différer les changements structurels (créer/détruire/ajouter) en utilisant EntityCommandBuffer pour éviter de casser la planification des jobs

Éviter

  • Éviter d'ajouter des types managés (classes, strings, arrays) aux composants car ils cassent la compilation Burst
  • Ne pas effectuer de changements structurels à l'intérieur de jobs parallèles ; utiliser EntityCommandBuffer.ParallelWriter à la place
  • Éviter d'interroger les entités une par une ; utiliser les requêtes d'entités et ToComponentDataArray pour les opérations par lots

Foire aux questions

Quelle version d'Unity supporte ECS ?
Unity 2022.2 LTS et versions ultérieures ont un support DOTS stable. Installer les packages Entities et Burst via le gestionnaire de packages.
En quoi ECS diffère-t-il de MonoBehaviour ?
ECS sépare les données (composants) du comportement (systèmes). Les composants sont de simples structs sans méthodes. Les systèmes contiennent la logique. Cela permet des dispositions mémoire favorables au cache et un traitement parallèle.
Puis-je mélanger ECS avec les GameObjects traditionnels ?
Oui, utiliser le Hybrid Renderer et les composants d'authoring pour convertir les GameObjects en entités. Pour les interactions au runtime, utiliser SystemAPI.GetComponent sur les entités et la manipulation de GameObject pour les approches hybrides.
Qu'est-ce que Burst et pourquoi devrais-je l'utiliser ?
Burst est un compilateur qui optimise le code C# en utilisant LLVM. Il produit du code machine natif hautement optimisé. Toujours appliquer [BurstCompile] aux jobs et systèmes pour des améliorations de performance de 10x et plus.
Combien d'entités ECS peut-il gérer ?
ECS peut gérer plus de 100 000 entités sur du matériel moderne. Les performances dépendent de la localité du cache, de l'efficacité des jobs et de l'évitement des goulots d'étranglement sur le thread principal. Profiler pour identifier les limites.
Devrais-je utiliser les Aspects ou l'accès direct aux composants ?
Les Aspects améliorent l'organisation du code lors de l'interrogation de la même combinaison de composants à travers plusieurs systèmes. Pour des requêtes simples, l'accès direct via SystemAPI.Query est plus clair.

Détails du développeur

Structure de fichiers

📄 SKILL.md