Pulsors

The Pulsor system is a physics-driven interaction layer. A PulsorComponent emits typed pulses when its physics trigger fires. PulseReactorComponents on other entities receive and process those pulses based on their type. The system is fully extensible — new pulse and reactor types are discovered automatically through O3DE serialization, so new interaction types can be added from any gem without modifying GS_Interaction.

For usage guides and setup examples, see The Basics: GS_Interaction.

 

Contents

• Architecture
• Components
• Pulse Types
• Reactor Types
• Extension Guide
• See Also

---

Architecture

Breakdown

When an entity enters a Pulsor’s trigger volume, the Pulsor emits its configured pulse type to all Reactors on the entering entity:

Step	What It Means
1 — Collider overlap	Physics detects an entity entering the Pulsor’s trigger volume.
2 — Pulse emit	PulsorComponent reads its configured PulseType and prepares the event.
3 — Reactor query	Each PulseReactorComponent on the entering entity is checked with IsReactor().
4 — Reaction	Reactors returning true have ReceivePulses() called and execute their response.

Pulse types are polymorphic — new types are discovered automatically at startup via EnumerateDerived. Any gem can define custom interaction semantics without modifying GS_Interaction.

E Indicates extensible classes and methods.

Patterns - Complete list of system patterns used in GS_Play.

---

Components

PulsorComponent

Emits typed pulses when its physics trigger fires. Extends AZ::Component and PhysicsTriggeringVolume.

Property	Type	Description
Pulse Types	vector<PulseType*>	The pulse types this pulsor emits on trigger.

The pulsor fires all configured pulse types simultaneously when an entity enters its trigger volume.

---

PulseReactorComponent

Receives and processes typed pulses from pulsors.

Bus: PulseReactorRequestBus (ById, Multiple)

Method	Parameters	Returns	Description
ReceivePulses	—	void	Process incoming pulse events.
IsReactor	—	bool	Returns whether this component is an active reactor.

---

Pulse Types

Pulse types define what kind of interaction a pulsor emits. All types extend the abstract PulseType base class.

Type	TypeId	Description
PulseType (base)	{8A1B2C3D-4E5F-6A7B-8C9D-0E1F2A3B4C5D}	Abstract base class for all pulse types.
Debug_Pulse	{123D83FD-027C-4DA4-B44B-3E0520420E44}	Test and debug pulse for development.
Destruct_Pulse	{98EC44DA-C838-4A44-A37A-FA1A502A506B}	Destruction pulse — triggers destructible reactions.

Pulse Types API

---

Reactor Types

Reactor types define how an entity responds to incoming pulses. All types extend the abstract ReactorType base class.

Type	TypeId	Description
ReactorType (base)	{9B2C3D4E-5F6A-7B8C-9D0E-1F2A3B4C5D6E}	Abstract base class for all reactor types.
Debug_Reactor	{38CC0EA0-0975-497A-B2E5-299F5B4222F7}	Test and debug reactor for development.
Destructable_Reactor	{47C9B959-2A9F-4E06-8187-E32DDA3449EC}	Handles destruction responses to Destruct_Pulse.

Reactor Types API

---

Extension Guide

Use the ClassWizard templates to generate new pulse and reactor classes with boilerplate already in place — see GS_Interaction Templates:

• PulsorPulse — generates a new PulseType subclass with a named channel and payload stub. Supply type_display_name and type_category input vars to control how it appears in the editor dropdown.
• PulsorReactor — generates a new ReactorType subclass. Supply the required pulse_channel var — the channel string is baked into the header at generation time.

To create a custom pulse or reactor type manually:

1. Create a class extending PulseType (or ReactorType) with a unique RTTI TypeId.
2. Reflect the class using O3DE’s SerializeContext and EditContext. The system discovers the new type automatically.

Channels are string-matched at runtime — keep the channel string consistent between the Pulse and the Reactor that receives it.

---

See Also

For related resources:

• Targeting
• World Triggers
• Framework API: GS_Interaction

---

Get GS_Interaction

GS_Interaction — Explore this gem on the product page and add it to your project.

1 - Pulse Types

Pulse types define what kind of interaction a PulsorComponent emits. Each pulse type is a data class extending the abstract PulseType base. The PulsorComponent holds an array of pulse types and emits all of them simultaneously when its physics trigger fires.

For usage guides and setup examples, see The Basics: GS_Interaction.

Component

PulsorComponent

Emits configured pulse types when its physics trigger fires. Extends AZ::Component and PhysicsTriggeringVolume.

All pulse types in the array fire simultaneously on a single trigger event. Configure multiple pulse types to target reactors on different channels in one emission.

Base Class

PulseType

Abstract base class for all pulse types. Not a component — discovered automatically at startup via EnumerateDerived and reflected into the editor dropdown.

Subclass PulseType to define custom pulse data (damage values, force vectors, status effect references) and a unique channel name.

Built-in Types

Debug_Pulse

Test and debug pulse for verifying pulsor setups during development.

Use Debug_Reactor on the receiving entity to verify the pulse is arriving correctly.

Destruct_Pulse

Destruction pulse — triggers destructible reactions on receiving entities.

Pair with Destructable_Reactor on entities that should respond to destruction events.

Creating Custom Pulse Types

Use the ClassWizard PulsorPulse template to scaffold a new PulseType subclass with boilerplate already in place — see GS_Interaction Templates. Supply type_display_name and type_category input vars to control how the type appears in the editor dropdown.

To create a custom pulse type manually:

1. Create a class extending PulseType with a unique RTTI TypeId.
2. Override GetChannel() to return a unique channel name string.
3. Add any data fields your pulse carries (damage values, force vectors, status effect references).
4. Reflect the class using O3DE’s SerializeContext and EditContext. The system discovers the type automatically via EnumerateDerived — no registration step required.
5. Configure PulsorComponent instances to emit your custom pulse type.

Keep the channel string consistent between your pulse type and the reactor types that should receive it.

See Also

• Reactors
• Pulsors Overview

Get GS_Interaction

GS_Interaction — Explore this gem on the product page and add it to your project.

2 - Reactor Types

Reactor types define how a PulseReactorComponent responds to incoming pulses. Each reactor type is a data class extending the abstract ReactorType base. The PulseReactorComponent holds an array of reactor types and processes all of them when a matching pulse arrives.

For usage guides and setup examples, see The Basics: GS_Interaction.

Component

PulseReactorComponent

Owns and processes reactor types when pulses arrive from PulsorComponent instances. Extends AZ::Component.

Bus: PulseReactorRequestBus (ById, Multiple)

The PulsorComponent queries IsReactor() first — only components that return true have ReceivePulses() called. This allows entities with no reactor types to be skipped without iterating all types.

Base Class

ReactorType

Abstract base class for all reactor types. Not a component — discovered automatically at startup via EnumerateDerived and reflected into the editor dropdown.

Subclass ReactorType to define custom reaction behavior for a specific channel. The channel string must match the emitting PulseType’s channel exactly.

Built-in Types

Debug_Reactor

Test and debug reactor for verifying reactor setups during development. Logs a message when it receives a Debug_Pulse.

Destructable_Reactor

Handles destruction responses — processes Destruct_Pulse events on the receiving entity.

Add this to any entity that should respond to destruction pulses — props, breakables, or enemy characters.

Creating Custom Reactor Types

Use the ClassWizard PulsorReactor template to scaffold a new ReactorType subclass with boilerplate already in place — see GS_Interaction Templates. Supply the pulse_channel input var — the channel string is baked into the generated header at generation time.

To create a custom reactor type manually:

1. Create a class extending ReactorType with a unique RTTI TypeId.
2. Override GetChannel() to return the channel name this reactor listens on.
3. Override React(pulse, sourceEntity) to implement the reaction logic.
4. Reflect the class using O3DE’s SerializeContext and EditContext. The system discovers the type automatically via EnumerateDerived — no registration step required.
5. Add the custom reactor type to PulseReactorComponent instances on entities that should respond.

The channel string in GetChannel() must exactly match the GetChannel() return value of the PulseType you want to receive.

See Also

• Pulses
• Pulsors Overview

Get GS_Interaction

GS_Interaction — Explore this gem on the product page and add it to your project.