Habilidades unity-ecs-patterns
📦

unity-ecs-patterns

Seguro

Implementar Padrões Unity ECS

Criando jogos Unity de alto desempenho requer padrões especializados orientados a dados que a OO tradicional não pode fornecer. Esta habilidade fornece padrões ECS prontos para produção usando DOTS, Jobs e Burst para jogos que escalam para milhares de entidades.

Suporta: Claude Codex Code(CC)
📊 69 Adequado
1

Baixar o ZIP da skill

2

Upload no Claude

Vá em Configurações → Capacidades → Skills → Upload skill

3

Ative e comece a usar

Testar

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

Resultado esperado:

  • Component Definition:
  • ```csharp
  • public struct Health : IComponentData
  • {
  • public float Current;
  • public float Max;
  • }
  • ```
  •  
  • Healing System:
  • ```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
  • );
  • }
  • }
  • }
  • ```

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

Resultado esperado:

  • 1. Create an Authoring MonoBehaviour:
  • ```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. Add the authoring component to a GameObject in the Editor
  • 3. The baking system automatically converts it to an entity at build time

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

Resultado esperado:

This requires a spatial hash approach. First, build a spatial hash map in a parallel job. Then run a second pass that queries nearby cells and applies damage. The spatial hash function uses prime number multiplication for uniform distribution: `hash = x * 73856093 ^ y * 19349663 ^ z * 83492791`.

Auditoria de Segurança

Seguro
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
Arquivos analisados
1,194
Linhas analisadas
0
achados
5
Total de auditorias
Nenhum problema de segurança encontrado
Auditado por: claude Ver Histórico de Auditoria →

Pontuação de qualidade

38
Arquitetura
100
Manutenibilidade
87
Conteúdo
22
Comunidade
100
Segurança
87
Conformidade com especificações

O Que Você Pode Construir

Desenvolvedor Indie Criando Jogos Críticos para Performance

Crie sistemas de jogo eficientes que lidam com milhares de inimigos, partículas ou unidades sem degradação de performance usando padrões ECS.

Programador de Gameplay Aprendendo DOTS

Transição dos padrões tradicionais Unity MonoBehaviour para arquitetura ECS orientada a dados com exemplos guiados e melhores práticas.

Artista Técnico Criando Sistemas de Partículas

Construa sistemas de partículas e efeitos massivos que processam em paralelo usando Jobs e compilação Burst para performance semelhante a GPU em CPU.

Tente Estes Prompts

Componente ECS Básico
Crie um componente Speed e um MovementSystem em Unity ECS usando ISystem e BurstCompile. O sistema deve mover entidades para frente baseado no valor de velocidade.
Sistema de Spawning de Entidades
Escreva um SpawnSystem que usa EntityCommandBuffer para criar entidades em runtime com um componente Spawner. Inclua versões single-threaded e job paralelo.
Personagem Baseado em Aspect
Crie um CharacterAspect que agrupa componentes Health, Speed e LocalTransform. Inclua um método para aplicar dano que respeita lógica de absorção de escudo.
Sistema de Hash Espacial
Construa um sistema de hash espacial usando NativeParallelMultiHashMap para consultas eficientes de colisão. Inclua a função hash e job paralelo para atualizar a grade espacial.

Melhores Práticas

  • Use ISystem em vez de SystemBase para máxima performance e compatibilidade com Burst
  • Sempre aplique [BurstCompile] em jobs e sistemas para performance otimizada
  • Adie mudanças estruturais (criar/destruir/adicionar) usando EntityCommandBuffer para evitar quebrar scheduling de jobs

Evitar

  • Evite adicionar tipos gerenciados (classes, strings, arrays) em componentes pois eles quebram compilação Burst
  • Não realize mudanças estruturais dentro de jobs paralelos; use EntityCommandBuffer.ParallelWriter
  • Evite consultar entidades uma a uma; use entity queries e ToComponentDataArray para operações em lote

Perguntas Frequentes

Qual versão do Unity suporta ECS?
Unity 2022.2 LTS e versões mais recentes têm suporte DOTS estável. Instale os pacotes Entities e Burst via Package Manager.
Como ECS é diferente de MonoBehaviour?
ECS separa dados (comportamentos) de comportamento (sistemas). Componentes são structs simples sem métodos. Sistemas contêm lógica. Isso permite layouts de memória cache-friendly e processamento paralelo.
Posso misturar ECS com GameObjects tradicionais?
Sim, use o Hybrid Renderer e componentes authoring para converter GameObjects para entidades. Para interações em runtime, use SystemAPI.GetComponent em entidades e manipulação de GameObject para abordagens híbridas.
O que é Burst e por que devo usar?
Burst é um compilador que otimiza código C# usando LLVM. Ele produz código nativo de máquina altamente otimizado. Sempre aplique [BurstCompile] em jobs e sistemas para melhorias de performance de 10x ou mais.
Quantas entidades ECS consegue lidar?
ECS pode lidar com mais de 100.000 entidades em hardware moderno. A performance depende de cache locality, eficiência de jobs e evitando gargalos na main thread. Faça profiling para identificar limites.
Devo usar Aspects ou acesso direto a componentes?
Aspects melhoram organização de código quando consultando a mesma combinação de componentes em múltiplos sistemas. Para consultas simples, acesso direto via SystemAPI.Query é mais claro.

Detalhes do Desenvolvedor

Estrutura de arquivos

📄 SKILL.md