unity-ecs-patterns
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.
Télécharger le ZIP du skill
Importer dans Claude
Allez dans Paramètres → Capacités → Skills → Importer un skill
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ûrAll 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.
Score de qualité
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
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.
Write a SpawnSystem that uses EntityCommandBuffer to create entities at runtime with a Spawner component. Include both single-threaded and parallel job versions.
Create a CharacterAspect that groups Health, Speed, and LocalTransform components. Include a method to apply damage that respects shield absorption logic.
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 ?
En quoi ECS diffère-t-il de MonoBehaviour ?
Puis-je mélanger ECS avec les GameObjects traditionnels ?
Qu'est-ce que Burst et pourquoi devrais-je l'utiliser ?
Combien d'entités ECS peut-il gérer ?
Devrais-je utiliser les Aspects ou l'accès direct aux composants ?
Détails du développeur
Auteur
wshobsonLicence
MIT
Dépôt
https://github.com/wshobson/agents/tree/main/plugins/game-development/skills/unity-ecs-patternsRéf
main
Structure de fichiers
📄 SKILL.md