Lyra Breakdown - Plugins Structure
Looked into the Plugins in Lyra so you don't have to. They were compiled together with related documentations to ease searching
The content in this post is based on Unreal Engine 5.5.4
If I made a mistake, please comment below and help future readers!
This is a series of notes about what I’ve learned from Epic’s Lyra project. Which claim to be the best practices under current unreal engine framework. Some I don’t know about, some I already know but I thought it would still be good noting down.
All Plugins and Categories
Lyra has enabled a huge amount of plugins, and they can be categorized into quite a few groups span across all the way from backend to frontend. The mindset here is, all these plugins are more or less contributing to the actual project features, so it’s quite hard to talk about them without going through the actual project. Nevertheless, we will go through them thoroughly, and here’s the first bite:
Here’s also some other posts about plugins at here Lyra’s Plugins, here UE5 Study, here Zomg’s Unreal Engine Notes and here Standard Plugins
Settings
From Lyra’s Plugins: “Adds base classes for handling a settings screen in your project.
It builds off of CommonUI’s ActivatableWidgets, so it will be using that system for its base screen classes.
Something to note is all the settings data is declared in C++, meaning designers won’t be able to expand upon it without engineering help.”
Editor Tools
A plugin that adds a new tab to the editor that allows you to quickly add actors to your level. This will basically open up a new level and allowing us to drag and drop actors from one to another.
Simple Video Tutorial:
From Lyra’s Plugins:
“Adds EUW_MaterialTool, an editor widget seemingly useful in the Lyra Material editor.
Also adds a BP function Change Mesh Materials, which explicitly invokes PostEditChange when meshes change.”
Asset Management
C++ utility class for managing asynchronous operations like loading.
An advanced system for managing data assets in Unreal Engine. It allows us to create a registry of data assets and provides a way to query and manipulate them at runtime. It advances the DataTable or CurveTable system, it’s more like a database.
The biggest advantage of which is DataRegistry provides a decoupled way to pull data from any viable resources but with a unified API. We no longer need to read a hard reference to a DataTable or CurveTable, we can just use the DataRegistry API to pull data from any source. Sync or Async, and even cached.
Official Documentation: Data Registry
Tutorial: Data Registry Tutorial
This is a plugin that can used to enhance the search functionality in Unreal Engine. It allows us to search for assets in our project using various criteria, such as asset type, name, and tags. Or even parameters like const strings we are printing.
A plugin to block some asset from being referenced by other assets. This is useful for preventing circular dependencies or ensuring that certain assets are not used in specific contexts. Like a DLC data should reference the base game, but not the other way around.
Geometry Tool
Add a new editor mode to Unreal Engine that allows us to create and manipulate 3D models directly in the editor. This is useful for creating custom assets or modifying existing ones without having to leave the editor. However, I think this is more a prototype tool than a production tool, as it doesn’t have the same level of control and precision as a dedicated 3D modeling software like Blender or Maya.
Community Documentation: Modeling Tools Community Docs
Video Tutorial:
Very much alike houdini where procedural modeling can be achieved with this plugin. It could also be useful to do stuff like generate collision boxes or other geometry at runtime.
Official Tutorial: Geometry Scripting Official Tutorial
Community Tutorial: Geometry Scripting Community Tutorial
Render & GFX
A library of volume creation and rendering tools using Blueprints.
The plugin provides a VolumetricCloudFunctions.ush file
The VFX system in Unreal Engine, which is used for creating complex particle effects and simulations. It allows for real-time rendering of particles, fluids, and other visual effects.
Official documentation: Niagara
The Water plugin in Unreal Engine is used for creating realistic water surfaces and effects. It provides tools for simulating water physics, reflections, refractions, and other water-related visual effects.
Official documentation: Water
Animations
A Blueprint Library that provides a set of functions for DistanceMatching and CharacterMovement
Distance Matching Document is an example of how to use the library in action.
A library to provide utilities about animation warping, such as OrientationWarping, SlopeWarping, StrideWarping, etc.
This plugin does all the heavy lifting for us to sync multiple characters’ animations together in a montage, so that we can make cool execution finishers, sit down on a chair smoothly, pull our hands on a wall, to name a few.
A great CAS Tutorial can be found here
Audio
No need to introduce this, cuz it’s famous enough and complex enough to even start. Epic has a dedicated Metasound Documentation for it.
This plugin adds Audio Modulation and Control Bus, as well as Control Bus Mix to Unreal Engine, function wise, it is slightly similar to what the previous UE4’s audio duck down system does. But having a control bus is a more flexible and powerful way to manage audio in Unreal Engine. And the user experience is also much closer to a professional DAWs like Wwise.
Audio Modulation Quick Start is a good place to start.
Audio Modulation Documentation for more details.
A small plugin that can allow a volume to control the audio features like reverb, etc. Which normally would be done manually with a blueprint or code. This plugin has already took care of stuff like Reverb, Submix, Attenuation, etc. The idea behind it was normally we are setting reverb either directly to the sound source itself staticly. Or through submix dynamically, or controlled by RTPC dynamically in metasound. Now it can be take care off by a real geometry. So we can say any sound that happens in a specific volume will have a reverb, anything outside of this volume would have a LFP, etc
Related documentation Audio Gameplay Volume
This plugin is a little bit like Gameplay Ability, except that now it’s the audio component that responding to (being triggered by) Gameplay events, so we can make stuff like when entered a place, interacted with something, looked at something, health below a certain threshold - to trigger a audio related logic.
A utility library for sound related info, like GetQFromBandwidth, ConvertDecibelsToLinear, GetFrequencyFromMIDPitch, GetBeatTemp, etc.
Provides a FSourceSpatializer struct and FITDSpatialization class for processing ITD spactialization.
Cinematic
The framework is the Unreal way to offline render for linear content, such as movies, cinematics, and other high-quality visual content. It provides a set of tools and features for rendering high-quality images and videos from Unreal Engine.
Official documentation: Movie Render Pipeline
Added additional render passes to the Movie Render Pipeline, such as MoviePipelineObjectIdPass and MoviePipelinePanoramicPass.
UI
A revolutionary plugin that solves the painpoints for most games UI system, an extension of UMG but kinda completely obsoletes UMG. There’re plenty of resources on the internet.
Official documentation: CommonUI Plugin
From Lyra’s Plugins: “Adds base classes and settings for handling a loading screen.”
A framework to handle loading screens, including CommonStartupLoadingScreen and ``CommonLoadingScreen` modules.
It took care of blocking inputs during loading, and can be used to hide streaming levels for X seconds as well. It will per tick query all the way from level to game state to each game actors that implemnted ILoadingProcessInterface to decide whether a loading screen is needed.
From Lyra’s Plugins: “Provides Subtitle Display Subsystem.”
It also binds widgets of game substitles to a Media Player
From Lyra’s Plugins: “UI Extension Overview: UIExtension Documentation
Provides a map of Extension Point Gameplay Tag to Activatable Widget.
In this way you can access any widget you want/need via its Extension Point, and it is organized into your HUD as defined by the parent layout.
For example, you can load in different Widget classes depending on the type of Lyra Experience you load in a Game Feature Plugin. The score might go into the same location on the HUD, but be a different widget depending on the Experience.”
Think of this as a harbour, where the main UI will define a port - an arbitrary extension point (Health Bar Area, etc), then no matter what the actual UI is (From Game Feature Plugin or whatever), that UI will be hooked to the port and being rendered.
Input
Again, a famous new system that replaces the old input system in UE4. No need for introduction.
Official documentation: Enhanced Input
A plugin that detects the DualShock controller input on Windows.
Although I wasn’t really sure why not just use RawInput plugin directly. Raw Input Documentation can be found here.
Network
A new replication system that allow more granular and nuanced control over what and how data is replicated over the network. It leverages the replication graph nodes to determin what’s being replciated to whom, and cache the data for much scalable and efficient replication. With this plugin, FNBR can support 100+ players and 50000 replicated actors in a session without bloating the network and CPU.
Official Documentation: Replication Graph
Official Livestream: Replication Graph Live Stream
An component to encrypt and decrypt the network packet data using AES-GCM algorithm. It is used to secure the network communication between the client and server, ensuring that the data is transmitted securely and cannot be intercepted or tampered with by malicious actors.
Another component used to encrypt the network, but instead of per packet data, it is used to secure the entire network connection using DTLS (Datagram Transport Layer Security) protocol. It is used to establish a secure connection between the client and server, ensuring that all data transmitted over the connection is encrypted and secure.
A plugin that supports the newer SteamSockets API, which is a more efficient and flexible way to handle network communication in Unreal Engine.
Official documentation: SteamSockets Documentation
Tutorial: SteamSockets Tutorial
As the name implies, this framework provides a standard shared point for online game services. Modules include HotFix, Lobby, LoginFlow, Party, PatchCheck, PlayTimeLimit, Qos, Rejoin
There aren’t many details available for this module online, so we will have to dig into the code ourselves and see how it’s been implemented in Lyra.
Support for Microsoft Azure PlayFab Party SDK. Unlike the other OSS, this one is more a VOIP solution.
Related Github repo: PlayFabMultiplayerUnreal
PlayFab OSS: PlayFab OSS
Support for Steam OSS. An OSS essentially is an abstraction layer that cooperates with the third party SDK, in this case, Steam, to properly distribute the game on steam and hook with Steam SDK’s session, authentication features.
It’s important to distinguish between OnlineSubsystem Plugin, OnlineServices Plugin and OnlineServices, OnlineSubsystemPlugin is an unreal concept that wraps up the third party, engine agnostic OnlineServices SDK. like Steam Online Service doesn’t really care which engine the game was made with. And then the OnlineServices Plugin is the modern UE5 abstraction layer that meant to replace the old OnlineSubsystem Plugin.
OS Official Documentation: Online Subsystem
Steam OSS Official Documentation: Online Subsystem Steam
Tutorial: UE Online Subsystem Steam Tutorial
Similar to Steam OSS, with the EOS as service provider.
EOS OSS Official Documentation: EOS OSS Documentation
Tutorial: EOS OSS Tutorial
The newer OnlineServices plugin that is meant to replace the old OnlineSubsystem plugin. It provides a more modern and flexible way to handle online services in Unreal Engine, allowing for easier integration with third-party services and better support for cross-platform play.
Official Documentation: EOS OSS Documentation, Online Service Overview
Basically a development OS plugin that doesn’t have a real backend but simulated one.
Tutorial: Setup and Configure Online Services and Structure and Implement the Online Services Plugins
A compatibility layer that allows the new OnlineServices plugin to work with the old OnlineSubsystem plugin. This is useful for projects that are transitioning from the old system to the new one, as it allows them to continue using their existing code and assets while taking advantage of the new features and improvements in the OnlineServices plugin.
Gameplay
This is a huge topic, before we dive into any of the plugins, Epic has a great documentation that helps us wrap our head around the gameplay framework in UE5. Make Interactive Experiences
The foundation work for gameplay features, it m provides Base classes and subsystems to support modular use of the gameplay framework. Like supporting injecting components into the game at runtime.
The UE5 way to implement modular game features. It allows us to create and manage game features in a modular way, making it easier to add, remove, or modify features without affecting the rest of the game.
From Lyra’s Plugins: “Base classes that allow for Game Feature Plugins to have the ability to load components, widgets, etc at runtime.
All of Lyra’s base classes are themselves based on Modular Gameplay Actors.”
Overview of a ModularGameplay Plugin: Modular Gameplay Plugin Overview
From Lyra’s Plugins: “Adds a system for utilizing CommonUI’s Activatable Widget Containers as “Layers”, and providing functions to push widgets to certain layers.
This is help for having your HUD on one layer and pushing a setting or pause menu to a layer above it.
This also makes it easy to use Gamepads to navigate your UI Menus, as they are all constructed using CommonUI Activatable Widgets in various Container layers.”
A framework for handling interactions for players and AI. Although it is the description of this plugin, but seems currently only NPC AI is supported, a huge amount of code is related to StateTree
From the uplugin description it says: “Encapsulated fire-and-forget behaviors for AI agents”. From the actual code it seems to be a wrap up of the behavior tree system. Combines blackboard values to gameplay tags.
Provide some API support for interacting with Smart Objects via Gameplay Behaviors.
This plugin provides a system for creating and managing smart objects in Unreal Engine. Smart objects are interactive objects that can be used by AI agents to perform specific actions or behaviors. The plugin provides a set of tools and features for creating, managing, and using smart objects in your game.
Official documentation: Smart Objects
State Tree is a new system for managing the state of anything that needs states switch (Even mainly used for AI) in Unreal Engine. It streamlines the process of we manually manage a state machine and provides a unified way to handle state transitions, actions, and conditions.
Official Documentation: State Tree
GAS is a huge topic that doesn’t need further introduction here. It’s one of the most discussed and documented system on the internet and is the go-to way of implementing interactions in a game in UE5.
Official Documentation: GAS
Community Documentation: GAS Community Docs
From Lyra’s Plugins: “Adds a system for you to broadcast and receive events across the game by Gameplay Tag, optionally including a custom struct with event data.
An example is if you kill someone it could broadcast an event under a specific tag that provides the name of the person you killed, and a UI widget could receive that event to display the kill.
These events are local-player-only, a nice compliment to Gameplay Ability System’s Gameplay Event which is replicated over the network. The two systems are roughly analogous, Gameplay Message Subsystem being local-client only scope and Gameplay Event with network client scope.”
A modular framework built around Gameplay Tags and Data Assets for managing branching dialogue and conversations in gameplay.
Designed to support both linear and branching dialogue trees, it allows NPCs and players to exchange messages, make choices, and respond based on gameplay state. Conversations can be defined entirely in assets, making them editable by designers without code.
A plugin that enables a modular and declarative way to define flow tasks in code. Like define a user login flow, or a series of steps to load a level, a quest line, whatever, you name it.
Tutorial can be found here: ControlFlows Tutorial
Authentication
From Lyra’s Plugins: “The Common User plugin provides a common interface between C++, Blueprint Scripting, and the Online Subsystem (OSS) or other online backends. It is a standalone plugin that can be used in any project.
Official Epic Docs: Common User Plugin
Provides Common User Subsystem, Common Session Subsystem and a Common User Initialize async action.”
QC
The plugins here are really useful for the Automation System, documented here Automation System Overview That can allow us to quickly create and run unit tests.
A testing framework that allows us to create and run functional tests in Unreal Engine. It provides a set of tools and features for creating, managing, and running tests in your game.
Official Documentation: Functional Testing
A framework that allows us to perform tests during runtime, whether in editor or cooked build.
There aren’t any officual documentations for this, so it would be better to just read from code, we will cover it when we go through the Lyra implementation.
This is another automation test framework that can run tests. Differnece is Gauntlet is targeting a broader picture, it’s not amiming for build the framework to test a specific gameplay feature, but rather to manage a whole Unreal Session, consider a multiplayer game test where we need to run 4 clients and 1 server, Gauntlet will get to correct build, fire up needed processes, run the tests, waiting for session quit, and then report the results.
Official Documentation: Gauntlet, Run Gauntlet Tests, Gauntlet Primer
Performance
From Gameplay Insights is a powerful profiling tool that helps analyze and visualize gameplay-related data such as replication, network traffic, ability usage, and more.
It integrates with Unreal’s Trace system and provides timelines, event traces, and stat tracking to diagnose performance and logic issues during gameplay. Lyra makes use of this for measuring ability activations and message routing performance.
Unknown Plugin, this plugin is enabled in Lyra, but does not exist in Unreal native plugins nor Lyra projects, prob. an Epic internal plugin that used to trace EGPU statistics.
This is a framework to provide more granular control over streaming or other custom treatments based on the significance of actors in a scene for optimization (Like some small VFX would just stop playing when the significance score is lower than a threshold).
It allows us to define and manage the significance of actors based on their distance from the camera, their visibility, and other factors. This can help improve performance by reducing the number of actors that need to be rendered or updated at any given time.
Official Documentation: Significance Manager
From Lyra’s Plugins:
“This plugin allows for easy streaming of levels.
It is designed as a cleaner, compact solution for the classic way to render 3D characters in menus, which usually implies loading a map outside the normal gameplay boundaries.
Excellent Pocket Worlds Example and documentation: Pocket Worlds Documentation”
Project Structure
Project can be categorized into even more modules. Before we go through them in the following posts, let’s first inspect them. (Some categories marked with “Extend” means they are more or less an extension of the core Lyra architecture. The project could still compile without them, they are crucial to the actual game content.)
This is only from codebase perspective, rather than actual game project perspective, for example, the Audio catrgory only have 2 classes in source code, but that doesn’t mean it’s a small feature, it just means the code didn’t extend them more, that’s it. In the actual Lyra project content, there’re ton’s of extensions that are done via MetaSound framework and custom blueprints.
Full Core
The core source of the project, the most basic and essential modules that are required for the project to function. These modules provide the foundation for the entire project and are typically genre agnostic.
Audio
- /Audio
- AudioMixEffectsSubsystem
- AudioSettings
Animations
- /Animation
- AnimInstance
Character
- /Character
- Pawn
- PawnData
- Character
- CharacterWithAbilities
- CharacterMovementComponent
- HealthComponent
- HeroComponent
- PawnExtensionComponent
Input
- /Input
- InputComponent
- InputConfig
Physics
- /Physics
- CollisionChannels
- PhysicalMaterialWithTags
Player
- /Player
- CheatManager
- DebugCameraController
- LocalPlayer
- PlayerBotController
- PlayerController
- PlayerSpawningManagerComponent
- PlayerStart
- PlayerState
Core Extension (Strong Relationship)
This part of the code is still very much related to the core of the game, but it is not as essential as the previous part. These modules provide additional functionality and features that are commonly used in many games, but they are not strictly necessary for the game to function.
Camera
- /Camera
- CameraAssistInterface
- CameraComponent
- PlayerCameraManager
- UICameraManagerComponent
- CameraMode
- (Extend) CameraMode_ThirdPerson
- (Extend) PenetrationAvoidanceFeeler
GameModes
- /GameModes
- ExperienceActionSet
- ExperienceDefinition
- ExperienceManager
- ExperienceManagerComponent
- GameMode
- GameState
- WorldSettings
- UserFacingExperienceDefinition
- (Extend) AsyncAction_ExperienceReady
- (Extend) BotCreationComponent
Development
- /Development
- DeveloperSettings
- PlatformEmulationSettings
- (Extend) BotCheats
Message
- /Messages
- VerbMessage
- VerbMessageHelpers
- (Extend) VerbMessageReplication
- (Extend) NotificationMessage
- (Extend) GameplayMessageProcessor
Performance
- /Performance
- PerformanceSettings
- PerformanceStatSubsystem
- PerformanceStatTypes
- (Extend) MemoryDebugCommands
System
- /System
- GameplayTagStack
- AssetManager
- AssetManagerStartupJob
- GameData
- GameSession
- SignificanceManager
- SystemStatics
- (Extend) GameEngine
- (Extend) GameInstance
- (Extend) ReplicationGraph
- (Extend) ReplicationGraphSettings
- (Extend) ReplicationGraphType
- (Extend) ActorUtilities
- (Extend) DevelopmentStatics
Core Extension (Weak Relationship)
This part of the code is less related to the core of the game, but it is still important for the overall functionality and features of the game. These modules provide additional functionality and features that might not be useful in all games, but they are still useful for many projects. More project specific.
Ability System
- /Abilities
- AbilitySimpleFailureMessage
- AbilityCost
- (Extend) AbilityCost_InventoryItem
- (Extend) AbilityCost_ItemTagStack
- (Extend) AbilityCost_PlayerTagStack
- (Extend) GameplayAbility
- (Extend) GameplayAbility_Death
- (Extend) GameplayAbility_Jump
- (Extend) GameplayAbility_Reset
- /Attributes
- AttributeSet
- (Extend) CombatSet
- (Extend) HealthSet
- /Executions
- (Extend) DamageExecution
- (Extend) HealExecution
- (Extend) /Phases
- (Extend) PhaseAbility
- (Extend) PhaseLog
- (Extend) PhaseSubsystem
- AbilitySet
- AbilitySourceInterface
- AbilitySystemComponent
- AbilitySystemGlobals
- AbilityTagRelationshipMapping
- GameplayCueManager
- GameplayEffectContext
- GlobalAbilitySystem
- TaggedActor
- (Extend) GameplayAbilityTargetData_SingleTargetHit
Feedback
- /Feedback
- /ContextEffects
- ContextEffectsLibrary
- (Extend) ContextEffectComponent
- (Extend) ContextEffectsInterface
- (Extend) ContextEffectsSubsystem
- (Extend) AnimNotify_ContextEffect
- (Extend) /NumberPops
- (Extend) DamagePopStyle
- (Extend) NumberPopComponent
- (Extend) NumberPopComponent_MeshText
- (Extend) NumberPopComponent_NiagaraText
- /ContextEffects
GameFeatures
- /GameFeatures
- GameFeatureAction_AddInputContextMapping
- GameFeatureAction_WorldActionBase
- (Extend) GameFeaturePolicy
- (Extend) GameFeatureAction_AddAbilities
- (Extend) GameFeatureAction_AddGameplayCuePath
- (Extend) GameFeatureAction_AddInputBinding
- (Extend) GameFeatureAction_AddWidget
- (Extend) GameFeatureAction_SplitscreenConfig
- (Extend) GameFeatureAction_WorldActionBase
Inventory
- /Inventory
- IPickupable
- InventoryItemDefinition
- InventoryItemInstance
- InventoryManagerComponent
- (Extend) InventoryFragment_EquippableItem
- (Extend) InventoryFragment_PickupIcon
- (Extend) InventoryFragment_QuickBarIcon
- (Extend) InventoryFragment_SetStats
UI
- /UI
- (Extend) /Basic
- (Extend) MaterialProgressBar
- (Extend) /Common
- (Extend) BoundActionButton
- (Extend) ListView
- (Extend) TabButtonBase
- (Extend) TabListWidgetBase
- (Extend) WidgetFactory
- (Extend) WidgetFactory_Class
- (Extend) /Foundation
- (Extend) ActionWidget
- (Extend) ButtonBase
- (Extend) ConfirmationScreen
- (Extend) ControllerDisconnectedScreen
- (Extend) LoadingScreenSubsystem
- (Extend) /Frontend
- (Extend) ApplyFrontendSettingsAction
- (Extend) FrontendStateComponent
- (Extend) LobbyBackground
- (Extend) /IndicatorSystem
- (Extend) IActorIndicatorWidget
- (Extend) IndicatorDescriptor
- (Extend) IndicatorLayer
- (Extend) IndicatorLibrary
- (Extend) IndicatorManagerComponent
- (Extend) SActorCanvas
- (Extend) /PerformanceStats
- (Extend) PerfStatContainerBase
- (Extend) PerfStatWidgetBase
- (Extend) /Subsystem
- (Extend) UIManagerSubsystem
- (Extend) UIMessaging
- (Extend) /Weapons
- (Extend) SCircumferenceMarkerWidget
- (Extend) CircumferenceMarkerWidget
- (Extend) SHitMarkerConfirmationWidget
- (Extend) HitMarkerConfirmationWidget
- (Extend) ReticleWidgetBase
- (Extend) WeaponUserInterface
- HUD
- (Extend) HUDLayout
- (Extend) ActivatableWidget
- (Extend) GameViewportClient
- (Extend) JoystickWidget
- (Extend) SettingScreen
- (Extend) SimulatedInputWidget
- (Extend) TaggedWidget
- (Extend) TouchRegion
- (Extend) /Basic
Replays
- /Replays
- ReplaySubsystem
- (Extend) AsyncAction_QueryReplays
Settings
- /Settings
- SettingsLocal
- SettingsShared
- (Extend) /CustomSettings
- (Extend) SettingKeyboardInput
- (Extend) SettingAction_SafeZoneEditor
- (Extend) SettingValueDiscrete_Language
- (Extend) SettingValueDiscrete_MobileFPSType
- (Extend) SettingValueDiscrete_OverallQuality
- (Extend) SettingValueDiscrete_PerfStat
- (Extend) SettingValueDiscrete_Resolution
- (Extend) SettingValueDiscreteDynamic_AudioOutputDevice
- (Extend) /Screens
- (Extend) BrightnessEditor
- (Extend) SafeZoneEditor
- (Extend) /Widgets
- (Extend) SettingsListEntrySetting_KeyboardInput
- (Extend) GameSettingRegistry
- (Extend) GameSettingRegistry_Audio
- (Extend) GameSettingRegistry_Gamepad
- (Extend) GameSettingRegistry_Gameplay
- (Extend) GameSettingRegistry_MouseAndKeyboard
- (Extend) GameSettingRegistry_Video
- (Extend) GameSettingRegistry_PerfStats
Teams
- /Teams
- TeamAgentInterface
- TeamCheats
- TeamDisplayAsset
- TeamInfoBase
- TeamPrivateInfo
- TeamPublicInfo
- TeamStatics
- TeamSubsystem
- (Extend) TeamCreationComponent
- (Extend) AsyncAction_ObserveTeam
- (Extend) AsyncAction_ObserveTeamColors
Tests
- /Tests
- GameplayRpcRegistrationComponent
- (Extend) TestControllerBootTest
Full Extension
This part of the code is not directly related to the core of the game, but it is still important for the overall functionality and features of the game. These modules provide additional functionality and features that might not be useful for all games, but they are still useful for many projects. Very project specific.
(Extend) Cosmetics
- (Extend) /Cosmetics
- (Extend) CharacterPartTypes
- (Extend) ControllerComponent_CharacterParts
- (Extend) CosmeticAnimationTypes
- (Extend) CosmeticCheats
- (Extend) CosmeticDeveloperSettings
- (Extend) PawnComponent_CharacterParts
(Extend) Equipment
- (Extend) /Equipment
- (Extend) EquipmentDefinition
- (Extend) EquipmentInstance
- (Extend) EquipmentManagerComponent
- (Extend) GameplayAbility_FromEquipment
- (Extend) PickupDefinition
- (Extend) QuickBarComponent
(Extend) Weapons
- (Extend) /Weapons
- (Extend) WeaponDebugSettings
- (Extend) WeaponInstance
- (Extend) WeaponSpawner
- (Extend) WeaponStateComponent
- (Extend) RangedWeaponInstance
- (Extend) GameplayAbility_RangedWeapon
- (Extend) DamageLogDebuggerComponent
- (Extend) InventoryFragment_ReticleConfig
(Extend) Hotfix
- (Extend) /Hotfix
- (Extend) HotfixManager
- (Extend) RuntimeOptions
- (Extend) TextHotfixConfig
(Extend) Interaction
- (Extend) /Interaction
- (Extend) /Abilities
- (Extend) GameplayAbilityTargetActor_Interact
- (Extend) GameplayAbility_Interact
- (Extend) /Tasks
- (Extend) AbilityTask_GrantNearbyInteraction
- (Extend) AbilityTask_WaitForInteractableTargets
- (Extend) AbilityTask_WaitForInteractableTargets_SingleLineTrace
- (Extend) IInteractableTarget
- (Extend) IInteractionInstigator
- (Extend) InteractionOption
- (Extend) InteractionQuery
- (Extend) InteractionStatics
- (Extend) InteractionDurationMessage
- (Extend) /Abilities