# Sistemas de partículas com IA no Unity: a extensão ParticleSystem — AI Game Dev

Agentes de IA leem e modificam todos os 24 módulos do ParticleSystem no Unity. Crie fogo, fumaça, efeitos mágicos e mais com prompts em linguagem natural.

Esta página foi traduzida automaticamente do inglês. [Leia o original em inglês](https://ai-game.dev/blog/unity-ai-particle-system-extension).

[Blog](https://ai-game.dev/pt-br/blog)

Agentes de IA leem e modificam todos os 24 módulos do ParticleSystem no Unity. Crie fogo, fumaça, efeitos mágicos e mais com prompts em linguagem natural.

Ivan Murzak · 24 de março de 2026 · 4 min de leitura ·

**Atualizado em 17 de outubro de 2026.** Desde o Unity-MCP 1.0.0 esta extensão é um módulo RQL em vez das duas ferramentas MCP descritas abaixo: o agente lê e edita todos os 24 módulos do ParticleSystem por meio de rql-query e rql-mutate. Os prompts deste post funcionam como antes. Detalhes atuais: ai-game.dev/docs/extensions/unity/particles e ai-game.dev/docs/rql.

O ParticleSystem do Unity é um dos componentes mais poderosos — e mais complexos — da engine. Com 24 módulos separados, centenas de parâmetros e configurações profundamente aninhadas, configurar um efeito de partículas à mão significa clicar por incontáveis painéis do inspector. E se você pudesse simplesmente dizer a uma IA "crie partículas de fogo que passam de laranja a transparente" e ter isso pronto em segundos? É exatamente isso que a extensão Unity-AI-ParticleSystem possibilita.

Partículas de fogo criadas e configuradas pela IA com a extensão ParticleSystem

## O que é Unity-AI-ParticleSystem?

Unity-AI-ParticleSystem é uma extensão do AI Game Developer que adiciona duas ferramentas MCP — particle-system-get e particle-system-modify — dando aos agentes de IA acesso total de leitura e escrita a todos os módulos do ParticleSystem no seu projeto Unity. Funciona com qualquer cliente de IA compatível com MCP: Claude Code, VS Code Copilot, Cursor, Windsurf e outros.

## Duas ferramentas, cobertura total

A extensão expõe apenas duas ferramentas MCP, mas elas cobrem tudo. A ferramenta get lê o estado atual de qualquer ParticleSystem, e a ferramenta modify aplica atualizações parciais — alterando apenas as propriedades que você especificar e deixando todo o resto intacto.

### particle-system-get

Recupera o estado completo de um ParticleSystem, incluindo o status de reprodução (isPlaying, isPaused, particleCount) e qualquer combinação dos seus 24 módulos. Você pode solicitar módulos individuais ou usar a flag includeAll para obter tudo de uma vez. O modo de serialização profunda expande objetos aninhados recursivamente para inspeção completa.

JSON Chamada de ferramenta MCP

```json
{
  "tool": "particle-system-get",
  "input": {
    "gameObjectRef": { "path": "/Effects/Fire" },
    "includeMain": true,
    "includeEmission": true,
    "includeColorOverLifetime": true
  }
}
```

### particle-system-modify

Aplica atualizações parciais a qualquer módulo. Apenas as propriedades incluídas na requisição são alteradas — todo o resto permanece como está. A ferramenta retorna logs detalhados de modificação para que a IA saiba exatamente o que foi atualizado.

JSON Chamada de ferramenta MCP

```json
{
  "tool": "particle-system-modify",
  "input": {
    "gameObjectRef": { "path": "/Effects/Fire" },
    "main": [
      { "memberPath": "duration", "value": 5.0 },
      { "memberPath": "startLifetime.constant", "value": 2.0 },
      { "memberPath": "loop", "value": true }
    ],
    "emission": [
      { "memberPath": "rateOverTime.constant", "value": 50 }
    ]
  }
}
```

## Todos os 24 módulos suportados

A extensão cobre cada um dos módulos do ParticleSystem disponíveis no Unity. A IA pode ler e modificar qualquer um deles:

- Main — duração, tempo de vida inicial, velocidade inicial, tamanho inicial, cor inicial, gravidade, espaço de simulação, loop
- Emission — taxa ao longo do tempo, taxa ao longo da distância, bursts
- Shape — tipo de forma, raio, ângulo, arco, posição, rotação, escala
- Velocity Over Lifetime — curvas de velocidade linear e orbital
- Limit Velocity Over Lifetime — limites de velocidade e amortecimento
- Color Over Lifetime — animação de cor baseada em gradiente
- Color By Speed — cor mapeada à velocidade da partícula
- Size Over Lifetime — curvas de tamanho ao longo do tempo de vida da partícula
- Size By Speed — tamanho mapeado à velocidade da partícula
- Rotation Over Lifetime — curvas de velocidade angular
- Noise — campos de turbulência e ruído Perlin
- Collision — configurações de colisão com o mundo e com planos
- Trails — renderização de rastros das partículas
- Renderer — material, mesh, modo de renderização, ordenação
- Além de: Force Over Lifetime, External Forces, Inherit Velocity, Lifetime By Emitter Speed, Rotation By Speed, Trigger, Sub Emitters, Texture Sheet Animation, Lights, Custom Data

## Uso no mundo real: o que você pode pedir à IA

Como a IA tem acesso total a cada parâmetro do ParticleSystem, você pode fazer pedidos em português comum e a IA descobre quais módulos e propriedades alterar:

- "Crie um efeito de fogueira com partículas de laranja a vermelho que sobem e desaparecem"
- "Deixe as partículas de fumaça maiores e mais lentas, com mais turbulência"
- "Adicione colisão para que as faíscas quiquem no chão"
- "Ative rastros nas partículas do projétil mágico"
- "Dobre a taxa de emissão e faça as partículas repetirem continuamente"
- "Mude a forma de cone para esfera e aumente o raio"

## Instalação

A extensão exige que o AI Game Developer (Unity-MCP) esteja instalado primeiro. Depois disso, adicione a extensão ParticleSystem via OpenUPM ou pelo instalador .unitypackage.

### Opção A: OpenUPM (recomendado)

Bash Terminal

```bash
openupm add com.ivanmurzak.unity.mcp.particlesystem
```

### Opção B: instalador de pacotes do Unity

Siga o download do instalador no README da extensão em [github.com/IvanMurzak/Unity-MCP/blob/main/extensions/ParticleSystem/README.md](https://github.com/IvanMurzak/Unity-MCP/blob/main/extensions/ParticleSystem/README.md) e importe o .unitypackage no seu projeto Unity via Assets > Import Package > Custom Package.

## Como funciona por baixo do capô

Os módulos do ParticleSystem do Unity são structs de C#, não classes — o que significa que não podem ser modificados por simples reflexão. A extensão usa ReflectorNet para fazer boxing de cada módulo, aplicar modificações por meio de diffs de membros serializados e então gravar o valor modificado de volta. Todas as chamadas à API do Unity são despachadas para a thread principal, e as janelas do editor são repintadas após cada modificação para que você veja as mudanças na hora.

C# Tool\_ParticleSystem.cs

```csharp
// The extension registers tools via attributes — Unity-MCP discovers them automatically
[AiToolType]
public partial class Tool_ParticleSystem
{
    [AiTool("particle-system-get", Description = "Get ParticleSystem data")]
    public async Task<string> GetParticleSystem(
        GameObjectRef gameObjectRef,
        bool includeMain = false,
        bool includeEmission = false,
        bool includeShape = false,
        // ... flags for all 24 modules
        bool includeAll = false,
        bool deepSerialization = true)
    {
        // Serializes requested modules and returns structured JSON
    }
}
```

## Compatibilidade

- Unity 2022.3 ou mais recente
- Requer AI Game Developer (Unity-MCP) v0.60.0+
- Funciona com qualquer cliente MCP: Claude Code, VS Code Copilot, Cursor, Windsurf, Continue
- Testado no Unity 2022.3, 2023.2 e Unity 6 (6000.3)

## Comece agora

Instale o AI Game Developer, adicione a extensão ParticleSystem e comece a descrever os efeitos que você quer. A IA cuida do resto. Confira o guia de início rápido em [ai-game.dev/docs/quickstart](https://ai-game.dev/docs/quickstart) para o passo a passo completo de configuração, ou baixe o plugin na página de download em [ai-game.dev/download](https://ai-game.dev/download).

- Unity-AI-ParticleSystem: [github.com/IvanMurzak/Unity-MCP/blob/main/extensions/ParticleSystem/README.md](https://github.com/IvanMurzak/Unity-MCP/blob/main/extensions/ParticleSystem/README.md)
- AI Game Developer (Unity-MCP): [github.com/IvanMurzak/Unity-MCP](https://github.com/IvanMurzak/Unity-MCP)
- Extensão AI Animation: [github.com/IvanMurzak/Unity-MCP/blob/main/extensions/Animation/README.md](https://github.com/IvanMurzak/Unity-MCP/blob/main/extensions/Animation/README.md)
- Extensão AI ProBuilder: [github.com/IvanMurzak/Unity-MCP/blob/main/extensions/ProBuilder/README.md](https://github.com/IvanMurzak/Unity-MCP/blob/main/extensions/ProBuilder/README.md)
- Download: [ai-game.dev/download](https://ai-game.dev/download)
- Guia de início rápido: [ai-game.dev/docs/quickstart](https://ai-game.dev/docs/quickstart)
- Tutorial de configuração: [ai-game.dev/blog/claude-code-unity-tutorial](https://ai-game.dev/blog/claude-code-unity-tutorial)

## Mais do blog

[Todos os posts](https://ai-game.dev/pt-br/blog)

### [De imagens de referência a um modelo 3D pronto para o jogo — Tripo AI dentro do AI Game Developer](https://ai-game.dev/pt-br/blog/tripo-ai-3d-models-from-reference-images)

26 de outubro de 2026

Transforme de duas a quatro vistas de referência em um modelo 3D com o Tripo no AI Game Developer e depois texturize, rigue e anime tudo pelo chat.

Ivan Murzak 7 min de leitura

### [Planeje primeiro, depois mude — Modo de plano para agentes de IA no desenvolvimento de jogos](https://ai-game.dev/pt-br/blog/plan-mode-ai-agent-game-development)

26 de outubro de 2026

Modo de plano, perguntas de esclarecimento, fila de mensagens e cartões de revisão no AI Game Developer para controlar o agente em tarefas grandes.

Ivan Murzak 6 min de leitura

---

Source (HTML): https://ai-game.dev/pt-br/blog/unity-ai-particle-system-extension

Machine-translated (pt-BR) from the English page: https://ai-game.dev/blog/unity-ai-particle-system-extension
