Description
Documentation | Discord | Videos | Demo
Hyper Event Manager v4
Let quests, inventory, UI and world systems respond to the same event without building direct references between each of them. Hyper Event Manager provides named event registration, parameter passing and shared dispatch for gameplay communication.
Key Features
Player and world events
- Player-specific managers: keep events such as item rewards or XP changes scoped to one player.
- Global managers: coordinate world events such as a captured area, defeated boss or weather change.
- Multiple listeners: let several systems respond to one registered event.
- Gameplay Tags: use organized identifiers for event names and related event families.
Payloads and integration
- Event parameters: pass the values listeners need, with structured payloads for more complex cases.
- Command and query results: use success/failure results for operations such as adding an item or checking a requirement.
- Quest and dialogue integration: trigger gameplay outcomes from narrative systems.
- Event-driven UI: refresh the interface when relevant events occur.
- Debugging: follow registrations and event flow when connecting systems.
Typical setup
Put a manager on the PlayerController for player-owned events and on the GameState for shared world events. Systems register their listeners during initialization and unregister when removed. A quest can then trigger an item reward without directly owning the inventory implementation.
Use the documentation examples to define a consistent event name, payload and result for your own systems.
32 reviews for Event Manager
You must be logged in to post a review.
Frequently asked questions
Why Hyper?
The strongest public modular Unreal Engine framework available at this scale
Most studios keep tools like this internal. Hyper makes a serious technical foundation available to solo developers, indies, and teams.
Built from 75,000+ hours of Unreal Engine work
System design, Blueprint architecture, multiplayer patterns, documentation, testing, integration, iteration, and real production problem-solving.
Systems designed to work together
Inventory, crafting, equipment, interaction, UI, combat, attributes, multiplayer, AI, quests, dialogue, maps, progression, survival systems, environment tools, performance helpers, and more can all live inside one larger ecosystem.
Working systems with source
Hyper gives you functional systems, a modular structure and documentation, with source you can extend for your own game.
Architecture you can extend
Hyper is built around scalable architecture: gameplay tags, structured data, child Blueprints, clean overrides, reusable components, and clear project boundaries.
Start fast, grow cleanly
Build on the included systems, replace visuals, adjust data, create child Blueprints and connect features without rebuilding the same foundation from scratch.
Want to learn more about the Hyper ecosystem, architecture philosophy, workflows, and developer behind it? Read more here and get started (https://gamesbyhyper.com/docs/getting-started/start-here/).
How do I add this to my project?
This module is provided as a full project because it includes Gameplay Tags, collision settings, config settings and other project-level dependencies.
Use our free Integration Tool (https://gamesbyhyper.com/product/integration-tool/) to prepare the integration. It combines compatible Hyper projects and handles migration and the required project settings. Use matching Unreal Engine versions and compatible Hyper releases.
Your own character, GameMode or custom systems may still need to be connected. The Integration Tool walkthrough (https://gamesbyhyper.com/docs/getting-started/use-the-automatic-integration-tool/) explains the setup and what to check in the generated project.
Do I need to use other Hyper systems with this?
No. You can use your own systems.
Hyper modules are designed around interfaces, abstract classes, shared contracts and dynamic dispatch, so features are not tied to one specific implementation.
If a module demonstrates integration with our Inventory, Equipment, Interaction, Movement, NPC or another Hyper system, you can:
Use the included Hyper implementation.
Replace it with your own system.
Use our implementation as a reference for your own integration.
The supplied integration shows how the module connects to the rest of a game. You can connect your own implementation through the same interface, abstract class or integration point.
For example, Attribute Manager may demonstrate Equipment modifying attributes. That does not mean you must purchase our Equipment System. You can follow the same integration pattern with your own equipment system.
The module includes working gameplay and its integration points. Build on the supplied setup or connect your own systems where you want different behavior.
See how to adapt a module (https://gamesbyhyper.com/docs/getting-started/customize-modules/) and how the shared data and abstract classes work (https://gamesbyhyper.com/docs/project-foundations/datamanagement/).
Where should I put my own changes?
Keep your own Blueprints, UI and data in your project's folder, for example Content/MyProject. Use child Blueprints or replacement components for your custom logic where possible.
That keeps your changes separate when you update Hyper. If you edit the original framework files directly, you will need to merge those edits when updating. The folder structure guide (https://gamesbyhyper.com/docs/project-foundations/folder-structure/) explains where everything belongs.
Can systems communicate without directly referencing each other?
Use Gameplay Tags to send events to listeners without hard references between every system. This is useful when quests, dialogue or world events need to trigger something elsewhere.
What can I use event payloads for?
Pass data such as variables, structures and object references to the receiving logic along with the event.
Compatibility and file information
- Development platforms
- Linux, Windows, macOS
- Tested platforms
- Windows
Versions and compatibility
| Version | Release | Unreal Engine |
|---|---|---|
| V4V4 UE5.7, 5.8. Release: V4. | V4 | 5.7, 5.8 |
Implementation and interaction
- Modular / extensible
- Yes
- Multiplayer ready
- Yes
- UI components
- Yes
- Input methods
- Gamepad, Keyboard, Mouse
- AI gameplay features
- No
System setup
- Architecture: registered callbacks routed through player-scoped or global event manager components.
- Ownership: PlayerController for individual player events; GameState for shared world events.
- Contract: event identifier, parameter payload and optional boolean success/failure.
- Return behavior: when multiple listeners return a result, all must report success for the combined result to be true.
Compatibility
- Networking: replicated multiplayer support.
- Platform testing: Windows tested.
- Plugins: Common UI.
Release notes | Documentation | YouTube | Discord
Documentation, videos and Discord are public. Verified buyers can use the support forums.
WHYPHY710 –
Review from FabIt’s simple straight forward logic that can manage your quests and so much more!
Dalcon4 –
Review from FabThe Hyper Event Manager v4 is a centralized event dispatching and scheduling framework that coordinates gameplay events across all systems and actors. It provides a unified event bus that decouples game systems, enabling complex event chains, timed triggers, conditional responses, and cross-system communication without direct dependencies between modules. The Event Manager is architecturally robust. It supports immediate and deferred event dispatch, timed and recurring event schedules, conditional event filtering, event priority ordering, event chaining for sequential workflows, listener registration and unregistration, and comprehensive event logging for debugging. The system handles high-throughput event scenarios without performance degradation. Using the Event Manager is intuitive. Register listeners for specific event types, dispatch events from any system, and the manager routes them to all registered handlers. Events are defined through a flexible typing system that supports custom data payloads. Adding new event types requires no modification to the core system. The Blueprint interface is clean and well-documented. Event dispatching is near-instant with negligible overhead. The routing system efficiently matches events to listeners without unnecessary iteration. Timed events fire with frame-accurate precision, and the priority system ensures critical events are processed before lower-priority ones. The debugging tools make it easy to trace event flows through complex system interactions.