Individual states can now add, remove, toggle, enable, or disable breakpoints directly. Breakpoints trigger when a state becomes active, stopping execution and focusing on the state.
A new Combat Template is now available as a content sample, developed by AAA veterans with Logic Driver combat experience. This template demonstrates how to build a responsive combat system using Logic Driver Pro, including:
Combo attack chains
Hit reactions
Directional dodging
State-machine-driven combat flow
All animations included are original assets and may be used in your projects as part of the Logic Driver license.
The system is fully customizable and designed to serve as a strong foundation for action-oriented gameplay in Unreal Engine using Logic Driver.
Additionally, the content samples have had some changes:
Renamed Combat Arcade to Objectives and AI and fixed AI not notifying nearby AI of the player's location.
Fixed lift state machines under Replication and Transition Events referencing a transition icon from Combat Arcade.
Updated each example's related docs links.
The Common library now includes UE's default level prototyping assets.
Gameplay tags can now be packaged with content samples.
The default transition icon is now an arrow that rotates to indicate transition direction. This aligns transition display with Anim State machines in UE 5.7 and improves graph readability. Note this does not impact self transitions and reroute nodes.
Added bApplyRotationToCustomIcon to transition instances, defaulted to false, for optionally applying the rotation to custom icons.
The transition icon now applies the hover color when hovered or when the previous state's output pins are hovered.
Slightly changed the default transition hover color to improve readability.
Added support for reading shortcut keys from the BaseEditorPerProjectUserSettings.ini config file, under a new LogicDriverSpawnNodes section, to spawn states in Logic Driver state machines.
BaseEditorPerProjectUserSettings.ini
[LogicDriverSpawnNodes]# Any state node+Node=(Class=/Script/SMSystem.SMAnyStateInstance Key=A Shift=false Ctrl=false Alt=false)# Standard state+Node=(Class=/Script/SMSystem.SMStateInstance Key=S Shift=false Ctrl=false Alt=false)# Standard state machine+Node=(Class=/Script/SMSystem.SMStateMachineInstance Key=S Shift=true Ctrl=false Alt=false)# Custom blueprint state+Node=(Class=/Game/StateMachines/ClassesRoom/CustomNodes/PrintTextState.PrintTextState_C Key=P Shift=false Ctrl=false Alt=false)# Custom native state+Node=(Class=/Script/SMSystemTests.SMStatePropertyResetTestInstance Key=V Shift=false Ctrl=false Alt=false)
Reduced compiled struct size of all node types in a state machine blueprint between 20%-50% to allow the creation of larger state machines.
Component
Old Size
New Size
Improvement
State Size
400
280
30.00%
Conduit Size
408
288
29.41%
Transition Size
408
320
21.57%
State Machine Size
728
352
51.65%
This required moving certain properties from FSMNode types to a new data container instantiated at runtime. Due to the nature of this change they could not be deprecated, but it is unlikely these properties are accessed by licensee code, as most of them were protected or private, and not available in blueprints.
Unreal Engine 4 and early UE5 versions had a garbage collection limit on total embedded struct sizes in blueprints. Exceeding this limit would crash the engine during blueprint compilation, affecting both Logic Driver and Animation state machines. Reducing the struct size means larger state machines can be created.
Epic removed this check in CL 25467921 (pre-UE 5.5), and initial testing shows blueprints should be able to safely exceed the previous limit. However, we're still adding this optimization as a precaution since the original purpose of the check remains unclear.
Graph properties now highlight when hovering over them.
Graph properties now automatically cleanup invalid pins after changing the underlying property type.
Transitions now support displaying messages (Note, Warning, Error) for improved validation feedback.
Node icons are now restricted to WITH_EDITOR_ONLY_DATA to reduce runtime overhead. If node icons are needed in release runtime, you will need to create a new variable.
Added SetManualInputController API to USMInstance to support reading input from a player controller that may not be directly attached to the instance.
Added Is Pin Wired API to the property editor interface.
Support providing a custom game instance to the Logic Driver preview mode.
Preview mode can accept the custom game instance as the context object.
Preview mode now displays the selected context object.
The debug toolbar is now available in preview mode.
Read-only variables, such as from user configuration or from playing in PIE, now dim their entire widget.
Added accent colors to property notify (validation) icons, making them similar to their UE4 appearance.
State stack names will now be displayed even if that state has no public properties to display on the graph node.
Added Open Stack Blueprint to state stack nodes' context menu.
The standard comment keybind (defaults to C) is now recognized in Logic Driver graphs.
Added support for toggling Named Transitions with a keybind; defaults to ALT+T.
Added a custom linear expression widget and interface which can be implemented in K2 nodes to customize their appearance in Logic Driver property widgets.
This also helps cleanup some alignment issues present in the engine provided linear expression widget.
OnTransitionEval and OnTransitionInitialize variable evaluation flags are now recognized on all state types, not just conduits.
Text graph properties now support UClass, TSoftClass, and TSoftObject default ToText conversions.
UClass and TSoftClass no longer support ToText dynamic function names by default. There is a backwards compatibility flag bApplyDynamicFunctionToClassTypes under Text Graph editor settings to enable this, but it is unlikely this ever impacted class types to begin with.
Fixed ability to add reroute nodes during PIE (Play in Editor).
Fixed reroute nodes incorrectly allowing connections back to their source state; self transitions should be used instead.
Fixed multiple issues when dragging and dropping a function onto a graph property:
Fixed function drop message being cleared when dragging over the graph property.
Prevented engine ensure when dropping the function directly on the pin.
Corrected function placement in the property graph to be consistent regardless of whether it was dropped on the property widget or the pin.
Eliminated rare edge case where the owning class could be modified during the drag operation, causing the drop operation to use the wrong class.
Fixed ability to drop variables or functions onto graph properties during PIE.
Fixed various issues with drag and drop operations:
Improved message display and responsiveness.
Corrected drop validation based on variable readonly state, graph edit state, and PIE session status.
Fixed reset to defaults being visible in the details panel for read-only properties.
Fixed crash when stopping a preview simulation while paused at a breakpoint.
Fixed a fast path optimization preventing breakpoints from triggering on the OnStateBegin K2 node.
Editor builds no longer use fast path for this entry point to support debugging, while release builds maintain the optimization.
Fixed default category display order on native state properties when using DisplayPriority or DisplayAfter meta specifiers.
Fixed category UCLASS specifier not being recognized when NodeDescription.Category is set to the default "User" value.
Note that child classes do not inherit this behavior.
When providing a class-level category specifier, it is recommended to set NodeDescription.Category to FText::GetEmpty() in the C++ constructor. This approach supports child classes. Remember to wrap with WITH_EDITOR_ONLY_DATA!
Fixed toggling a property's graph edit in certain cases not refreshing the view/edit graph details panel button.
Fixed TextGraph properties' view/edit graph text alignment when used in arrays.
Prevent TextGraph properties throwing the localization warning "Textgraph property '%s' on node '%s' may have saved the display text of a different language and is being corrected." during cook.
Marketplace build types are properly displayed again under the license and about page when downloading the plugin through FAB.
Plugin Entitlement Checks for UEM/FAB Marketplace Licensees
Automatic entitlement checks have been disabled for Logic Driver Pro due to a bug in the Epic Games launcher causing either a timeout or crash. You can still run an entitlement check under the Logic Driver license page, but it will fail until Epic Games addresses this issue.
Fixed Open Property Blueprint staying enabled when no property was selected.
Renamed the private FSMBlueprintEditor to FSMStateMachineBlueprintEditor. Exported access to this class was deprecated in 2.8, and the public ISMStateMachineBlueprintEditor interface should be used instead.
Support for Editor Construction Scripts set to Legacy (LDP 2.4 and earlier behavior) is being phased out and will be deprecated in a future release. Stable localization keys may not work properly on legacy construction scripts.
Fixed crash shutting down a state machine initializing async.
Fixed crash when initializing async during incremental garbage collection in world partition.
Fixed entry nodes having the wrong context menu options.
Fixed exposed gameplay tag queries not saving in UE 5.3+.
Fixed setting a Text Graph string table not automatically refreshing the node in UE 5.3+.
Additional Marketplace license validation checks have been added to help inform studios of their compliance with the Epic Games content license agreement for code plugins. Please review the updated licensing documentation.
This is only for Marketplace licensees, not studios licensed directly with Recursoft.
Known Issues
Unlocalized string tables assigned to Text Graph properties in UE 5.4 do not work and will return MISSING STRING TABLE ENTRY. This is an engine level regression from a last minute change introduced to UE 5.4.0, with a fix scheduled for UE 5.4.2. See issue.
Logic Driver Pro now ships with content samples which can be installed to projects.
The sample content contains Templates and Examples.
Templates contain both template blueprints which can be used within a project as well as sample maps and state machines showing how the template could be used.
Examples serve as basic examples demonstrating particular features.
The content is based on the previously available GitHub content and has been updated for Unreal Engine 5.
Content can be installed through a new Utility Launcher menu available on the level toolbar.
Transitions can now be renamed through the details panel and the name displayed in the state machine graph. The default behavior is to display renamed transitions on hover.
Added GetOutgoingTransitionByName, GetIncomingTransitionByName, and SwitchToLinkedStateByTransitionName to SMStateInstance_Base.
Added DisplayDefaultTransitionName and DisplayCustomTransitionName to editor settings. Default names default to Never, custom names default to OnHover.
Exposed object properties now have a custom BP pin for displaying the asset thumbnail. Hovering the thumbnail will show a higher res version. Sound types have a play sound button. Additionally the maximum width of the asset name text box has been extended.
Play Sound button will either appear over the thumbnail or next to the browse/use buttons if thumbnails are disabled.
Added OverrideObjectPins to project editor settings.
Added bDisplayThumbnailsByDefault to project editor settings.
Added DisplayThumbnail optional bool to NodeWidgetInfo for blueprint asset configuration.
Recognized meta = (DisplayThumbnail=true/false)
Read Metadata on Exposed Properties (GameplayTagContainer)ΒΆ
Property metadata is now returned from property pins. This benefits pins provided by the engine that read metadata, most notably supporting GameplayTagContainer metadata.
Now that enhanced input is no longer experimental in UE 5.1, official support has been added to state machines. Enhanced input actions in state machine graphs are supported similar to how legacy input actions are supported -- They should be automatically scoped to the corresponding state or transition and only execute when the node is active.
Configure Any State Tags from Editor Construction ScriptsΒΆ
A new interface representing USMGraphNode_StateNodeBase is available by calling AsStateBaseInterface from the USMEditorGraphNodeInterface. From here GetAnyStateTags and SetAnyStateTags interface functions are available.
Node assets no longer load into memory when opening the graph context menu or making a connection and instead are loaded when instanced in the graph.
This can significantly reduce initial load times and memory usage in the editor.
This means several properties on node instances are now asset registry searchable and node assets need to be resaved. Logic Driver's update process will prompt for this.
Optimized native derive node class lookup, ~90% faster.
This required several deprecations, please see the deprecations section.
Editor construction scripts now run in only one pass, improving construction performance by almost 50%.
Added a pre-pass which updates property values from pin values, allowing recently entered values to be recognized from other nodes without requiring a second pass.
Added NumConstructionScriptPasses property to state machine blueprint settings, in case a second pass is required.
The only reason for a second pass now should be if a property modified by one node's construction script needs to be read from another node.
Fixed C++ properties exposed to BP not being able to be referenced in text graphs.
Fixed collapsing a state machine not recognizing the Default Sub State Machine Class in rules.
Fixed notify state change being called multiple times on state machine references.
Fixed issues with calling SwitchActiveState on references not setting bHasStarted or calling OnRootStateMachineStart on nodes.
Fixed an ensure from loading the documentation module when compiling autobound transitions without the editor attached, such as in -game mode.
Fixed performance issues when GCing CDOs in editor builds.
Fixed a crash when the preview actor is destroyed on its own tick.
Fixed a crash when using ResetVariables with stack instances.
Fixed component events not firing if its SMInstance triggers events from OnStateMachineInitialized.
Fixed being unable to rename a state when using bShowDisplayNameOnly.
Fixed transition placement rules incorrectly passing when the required state class isn't loaded.
Fixed crash when compiling a node class that is used in a parent SM which has a child SM that calls that parent.
Fixed bFromLinkState not being set correctly on rerouted transitions.
Fixed LinkState chain icon showing up if there was no linked state destination and crashing when double clicking it. Destroying a destination state now correctly removes itself from the LinkState.
Fixed renaming a linked state not updating the LinkState node and supporting undo.
Fixed USMStateMachineInstance::OnEndStateReached not firing in certain circumstances.
Fixed editor monolithic linking build blockers and runtime crashes.
The following changes have been made to follow best practices, improve licensee use and support with the editor module, and decrease plugin build times and sizes.
A pass on all modules' header includes has been made, replacing many includes with forward declarations. It's likely projects may need to include more headers. IE, including SMInstance.h won't include SMTransitionInstance.h anymore.
The SMSystemEditor module has had many of its private headers refactored to public headers, some of which have been separated out into multiple headers.
Private headers are meant for use only within the plugin and do not respect semantic versioning, even if they are exported or inline. They can receive breaking changes during hotfixes and do not use deprecations.
The focus of the refactor is for headers used for type checking, graph traversal, and use with the SMAssetTools module for graph processing.
Headers used to extend graph properties are also public. See SMExtendedEditor's TextGraphPropertyNode.
Limited or removed some editor API exports not intended for use outside of the module.
New public interfaces and accessors have been added for several private classes which are more popular with licensees.
Added ISMEditorConstructionManager to replace accessing the FSMEditorConstructionManager.
Added ISMStateMachineBlueprintEditor to replace accessing the FSMBlueprintEditor.
Added FSMCompilerDelegates to replace accessing the static FSMKismetCompiler delegates.
Deprecated old delegates and accessors where possible to make this transition easier.
No longer export FSMKismetCompilerContext, FSMBlueprintEditor, FSMNodeBlueprintEditor, or FSMEditorConstructionManager.
Deprecated USMNodeInstance::IsInEndState(). This was ambiguous usage and would either check if a state was an end state, a state machine was in an end state, or a transition's previous state was in an end state. Now explicit methods should be called for each case.
Use USMStateInstance_Base::IsEndState() to check if a state is an end state.
Use USMStateMachineInstance::IsStateMachineInEndState() to check if the state machine is in an end state.
Transitions will need their previous state retrieved, casted to USMStateMachineInstance, and IsStateMachineInEndState called on it.
This also applies to the equivalent FSMNode methods.
Note that USMInstance::IsInEndState method is not being renamed currently, as it has no conflicting method names and its naming is consistent with other class methods.
Deprecated USMInstance::GetStateMachineClass() and SetStateMachineClass() in favor of GetRootStateMachineNodeClass() and SetRootStateMachineNodeClass().
Deprecated USMBlueprintUtils::K2_CreateStateMachineInstancePure(). This has been soft deprecated for multiple versions now in favor of the execution version.
Deprecated USMStateMachineInstance::GetAllowedStates() in favor of GetAllowedNodes.
Deprecated USMStateMachineInstance::StatePlacementRules in favor of NodePlacementRules.
Requires C++ usage updated.
Deprecated virtual method IsRegisteredWithContextMenu(). This is no longer used and if you were overriding this you now need to set bRegisterWithContextMenu in the C++ ctor instead.
Deprecated virtual method HideFromContextMenuIfRulesFail(). This is no longer used and if you were overriding this you now need to set bHideFromContextMenuIfRulesFail in the C++ ctor instead.
Deprecated bLetInstanceManageTick. This is a legacy property which has been intended to be deprecated for some time. It is unlikely to be used and adds unnecessary complexity, and is roadblocking future deprecations and refactoring. It still functions if set to true, but is planned to be removed in a future release.
Deprecated FSMGraphProperty_Base::GetVerticalDisplayOrder(). This has been obsolete for several versions now.
The following were deprecated as part of the private editor header refactor:
Fixed Text Graph Properties not evaluating properly when used within state machine references.
Fixed crash from modifying an array nested inside of a non-exposed struct on a node.
Fixed editor prompting for checkout of files that weren't dirty on startup.
Fixed json exporter not always exporting arrays properly.
Fixed json exporter including unnecessary compiler generated properties.
Limited GetStateMachineInstance warning during editor construction scripts to verbose logging.
The node compiler will now log a warning when an invalid variable name is used since this can cause problems in state machine graphs. This can be disabled through the project editor setting bRestrictInvalidCharacters.
Add OnPreCompileValidate to node classes, an editor only function to allow writing to the blueprint compiler log and signaling the type of log. This can display friendly messages to the designer and prevent blueprints from compiling.
Validation can occur for the entire node or a specific exposed property on the node.
Reroute nodes can be added via context menu or by double clicking on a transition. A rerouted transition always represents a single transition and has no impact at run-time.
From the graph node you can retrieve specific editor graph properties. Each property has several functions available for setting notifications. See the Graph Property Node Interface.
Using the interface with construction scripts allows real-time property validation.
Rich text can now be displayed within text graph properties. The rich text supports Unreal Engine's UMG rich text.
From a text graph's default settings select the rich text style or decorator classes to assign. This will only be used in the editor. At run-time the original text is output and it is up to your UMG widgets to display rich text.
All rich text will now be removed while editing the text graph. This impacts variables in the graph and they will now show up as {VARIABLE_NAME} when in edit mode.
When not in edit mode and a variable is in between rich style attributes, it will also show up as {VARIABLE_NAME} since Unreal Engine does not support nesting rich styles.
Inline variables and methods have always used rich text which is why they are impacted.
Custom importers and exporters can now be registered, allowing a state machine blueprint to be imported and exported to a custom format.
A basic JSON implementation is included with this update which can be used as a reference. It imports and exports state and transition template data -- including default property values -- but does not handle blueprint functions or variables.
Configuration of public node properties can now be done directly on the variable details panel. This will replace having to edit the ExposedPropertyOverrides array on the class defaults.
VariableCustomization can be disabled with the project editor setting bEnableVariableCustomization since VariableCustomization overrides of Logic Driver will overwrite other plugins customizing variables.
Note that UE 5.1 offers improved variable customization support for plugins.
Optimize the Initialize function on state machine instances by offloading work to the compiler and better caching information during initialize.
Profiling has shown blocking Initialize() calls to complete up to ~60% faster.
Most Guid calculations are now done during compile significantly reducing overall initialization time. Note this optimization doesn't apply to dynamic state machine references or debug builds.
Exposed graph properties more efficiently cache their data and initialize ~95% faster.
UFunction mapping is done during compile saving a FindFunctionByName call at runtime. Note this only benefits non-development builds.
Exposed functions (K2 entry points) for each node are now stored on the owning SMInstance CDO during compile and mapped to nodes during Initialize. This reduces the struct size embedded into each graph node during compile allowing larger state machines.
The blueprint compiler now generates all names and Guids deterministically so blueprint generated classes will stay consistent between compiles. This change is so patch generation won't include generated classes that haven't been modified.
Localization has been improved for Text Graph properties and FText properties.
Changing a localization setting in the node class defaults will now be used when placing new instances of the node and will also propagate to existing instances of the node.
Note that turning localization off with empty text does not always propagate correctly; Unreal Engine uses static FText for empty text which has localization enabled.
Text Graph Localization preview is now supported.
Construction Scripts can now modify localization of text graph properties.
FText properties have improved package and key handling. This fixes some cases where duplicate localization text was being gathered.
Non-exposed C++ properties on a node marked Instanced should now serialize during cook. This requires the object be created manually - such as through PostEditChangeProperty - with the outer as or belonging to the node instance template.
Instanced Maps and Sets are not supported.
Modify State Stack During Editor Construction ScriptsΒΆ
States can now be added or removed from the state stack during editor construction scripts.
Added wizard for creating new state machine assets.
Node class default property value changes will now propagate to loaded instances without requiring a compile.
The state picker pin can now be assigned to exposed FString properties in C++ with meta=(UseLogicDriverStatePicker).
Editor Construction Scripts now run on blueprint load.
Added UI indicator when a text graph is in graph edit mode.
Added a global ToTextDynamicFunctionName to a new Text Graph Editor Project Settings.
CreateStateMachineInstanceAsync in C++ has a return type of USMInstance. This will either be null if it wasn't created, or the not yet initialized instance.
When placing a transition through rules, the furthest child class that passes the rules will now be used instead of the first class found.
Support node context menu extensions
Added delegate to broadcast the toolmenu and graph node context when the graph schema is populating the context menu of a graph node. GetExtendGraphNodeContextMenu added to ISMSystemEditorModule.
Support node details panel extensions
Added delegate to broadcast the DetailBuilder when customizing a node instance on a state machine graph node. GetExtendNodeInstanceDetails added to ISMSystemEditorModule.
Allow newly placed nodes to collapse categories by default with Collapse Categories by Default editor preference.
Added PropertyPinColorModifier to editor preferences to customize exposed property pin color.
Added OnStateMachineShutdown override to SMInstances and components.
Automatically update network settings on pawn possession change.
Automatically re-register input during a replicated controller change. (UE5 only)
SetCanEverTick will now update the component's network tick settings if called from the primary instance.
Default transition classes will now respect bRunParallel when being placed.
Fixed object property pins crashing when retrieving tooltips after a modification, such as dragging a variable to the pin. (This is a work around of an engine bug)
Fixed long-standing issue of the debug filter not always persisting between PIE sessions.
Fixed using the same input actions in transitions causing a loop.
Fixed input axis events not being scoped to their node in UE5.
State machine references can be dynamically created at initialization time by assigning a Dynamic Class Variable. This allows a single reference node be assigned a different state machine blueprint at run-time and can greatly simplify graphs that need to be shared across different actors.
The replication system has been overhauled and is now more reliable and efficient.
Replication is now entirely reliable to ensure the same transition path is executed across all domains in the correct order.
New StateChangeAuthority is used to standardize behavior for both transitions and any manual state change calls. This replaces NetworkTransitionConfiguration.
Listen server configurations will be more consistent with dedicated server behavior.
Only owning clients will receive RPCs unless IncludeSimulatedProxies is enabled.
Replicated variables within state machine blueprints and references are now supported (but individual node classes are not).
Non-default categories for public properties will now be displayed on the node. Default properties will appear on the top with category order being maintained below.
The details panel has been updated to display properties under their correct category now.
Exposed arrays will show up on the top most category, but not nested categories.
States can be retrieved and set by their fully qualified name.
When the class type of the state machine is known, a state picker tree view will be available.
State Machines can now be initialized async. This is a multi-threaded solution to help reduce blocking operations on the game thread. See the Performance Guide's Async Initialization section for more information.
Create State Machine Instance is now an Execution FunctionΒΆ
An execution function is more appropriate as this is an expensive operation that instantiates and initializes a new state machine.
The original pure method has been renamed and soft deprecated. Going forward using the execution method is the preferred solution. Uses of the old function still work and do not have to be updated.
Running the local blueprint graph can now be avoided in more situations, especially benefiting C++ nodes. When a node avoids using a blueprint graph the fast path symbol will appear.
Rather than always instantiate node instances that don't have a custom class assigned, they will instead be loaded only if programmatically accessed. This should reduce memory usage and initialization times.
Exposed properties that have only default values can optionally avoid graph evaluation at runtime by unchecking Eval Default Properties in the node class.
Several methods of switching states have been updated to occur immediately at the time of execution during the same tick. Previously they could trigger a state change on one tick, but OnStateBegin wouldn't fire until the next tick. These changes will allow more precise control over frame sensitive state changes.
The following methods now execute immediately and have had their behavior slightly updated.
Automatic event bound transitions use a new optimized routine to only evaluate and take that specific transition at the time of the event, rather than the old way of performing a full transition evaluation of the state machine.
EvaluateFromManuallyBoundEvent has been improved to only evaluate and take the transition it was called for, making the behavior similar to how auto bound events function. When using manual bound events this is the preferred way of triggering evaluation now, instead of calling EvaluateTransitions.
Manual state change calls such as SetActive and SwitchToLinkedState will process the change immediately, but can be configured not to if needed.
It is now possible to manually configure the GUID to use for a state. This may be necessary if you have to update the structure of a state machine that has run-time save data associated with it.
Added Guid Redirect Map to state machine instances. This accepts an old PathGuid as the key and the new PathGuid as the value. A PathGuid is the GUID that is returned from GetGuid at run-time. This is the preferred solution for redirecting GUIDs and must be maintained on the primary instance, not on individual references.
Exposed NodeGuid to individual states in the state machine graph. This is only used in the final run-time GUID calculation, and in most circumstances it should not be changed.
Nodes can have their double click behavior customized under Editor Preferences to either open the local graph or an external graph, such as a node blueprint.
The default behavior for references has changed to always prefer the external state machine blueprint.
The intermediate reference icon can now be double clicked to open the local graph.
When opening an external graph the current debug object will be maintained.
StateChangeAuthority does everything NetworkTransitionConfiguration did, but also impacts behavior over manual state changes and general commands, like Start and Stop.
All transactions, not just transitions, will wait for a server response. This may impact behavior when using with manual state changes from the client as the client will remain in its current state until the server broadcasts the change.
Completely removed bReuseReference from state machine references. This is legacy behavior that is incompatible with many features and is no longer supported.
Adjusted shutdown sequence to avoid blueprint runtime errors from unbinding autobound transitions and rare crashes when shutting down the editor.
Fixed details panel sometimes clearing on modification.
Fixed a linkerload crash and improved sub-object packaging.
Fixed several crashes from force deleting node blueprints in use. (Force deleting any class that is in use has an inherit risk to it and should be avoided.)
Fixed setting a state machine reference intermediate graph, then undoing and saving causing a crash on BP reload.
Fixed calling GetNodeName on state machine references not returning the correct name.
Fixed nodes without construction scripts not having their variables read properly from other construction scripts.
Fixed and polished read only variables. All variable types set to read only should now be dimmed and restricted from editing. Property graphs will be made read only. Context options such as 'Reset Property' and 'Convert to Graph Edit' will be restricted based on status.
State changes will record the previous state as a struct containing the state guid, start time stamp, and time in state. Total history size can be configured.
History is maintained at the top level owning state machine.
Reset variables to their default values during run-time when a state is entered or on demand. This is an experimental feature, and should be used with caution.
Added experimental Reset Variables on Initialize advanced option to state class properties.
Default node instance properties such asbRunParallel have been assigned public C++/Blueprint Getters and Setters that will properly update the node values. This will allow most properties to be modified during run-time, with the primary purpose being for construction script use in the editor.
Some properties, such as transition Priority Order are restricted to construction use only.
Some editor only properties, such as NodeColor, DisplayName, will have DevelopmentOnly setters.
The original properties are changing from Public to Private so any C++ code that accesses them will have to be updated.
Changing ToText functions in a node class will automatically update the text graph instances.
Added ToTextDynamicFunctionName to the text serializer. This function is looked up dynamically during run-time. This allows any object type (such as a UObject) to be provided to the text graph and still support custom text serialization.
Each state stack state now respects its Auto Eval Exposed Properties configuration.
Removed EvalGraphPropertiesOnInitialize since that is redundant with OnStateBegin evaluation.
Added EvalGraphPropertiesOnInitialize and EvalGraphsOnTransitionEval to Conduits.
EvaluateGraphProperties can now target a specific state in the stack, rather than evaluate all states in the stack each time.
Transition delegate binding dropdown now searchable.
Improved compatibility with engine plugins by allowing blueprint menu extenders in state machine blueprints. (Configurable under Project Editor settings)
Fixed parallel states updating more than once from transition events.
Fixed edge case of OnStateBegin and OnStateEnd being called twice when a transition triggers OnStateEnd, and OnStateEnd also triggers a transition event.
Renaming a node is no longer a context menu option when the node title is hidden.
Blueprint local graph evaluation is now avoided for transitions with the following conditions:
The conditional result node defaults to true.
The conditional result node defaults to false.
The conditional result node is connected only to a Can Enter Transition node for a transition instance. This is mostly beneficial if your transitions are defined in C++.
Most state and transition settings previously only available in the state machine graph are now available in their node classes. This allows you to set defaults such as bExcludeFromAnyState at a class level.
All regular nodes will be assigned the default node class now. It is no longer possible to set a null class value.
Old values are imported into the new system. Please verify your state machines operate normally.
When the server is in charge of transitions it is now guaranteed the client will take the same transition path, rather than prioritize being on the current active state(s).
Added TransitionResetTimeSeconds to components which dictates the time to maintain the transition buffer over replication. Setting it to 0 is equivalent of the old behavior.
When updating it is important everyone working on the same project also updates. Assets saved on this version are not fully compatible with older versions.
Added bIncludeSimulatedProxies to actor components so actors that aren't possessed by a player controller can execute logic when configured for the client domain.
Improved initial instance replication which should resolve issues when leaving bInitializeOnBeginPlay checked not always starting the state machine on simulated proxies.
Initial replication now replicates the current state(s) of the authority state machine rather than rely on the default initial state being accurate.
Can be disabled by unchecking bReplicateStatesOnLoad
Manually calling the actor component Initialize function and not passing in a context will now automatically set the context to the component owner.
Renamed Editor and ProjectEditor settings from State Machine Editor to Logic Driver.
Deprecated bCanEnterTransition of conduit classes.
Creating a new conduit class no longer automatically wires a parent node to CanEnterTransition.
Instance compile validation skips blueprints that are new or loading.
Updated custom K2 node pin names to be consistent with UE4 naming conventions. Once you save a state machine on this version you cannot open it in an earlier version of Logic Driver or connections may be broken.
Rules can be assigned to each class to define which connections are allowed and where nodes can be placed.
This can be used to restrict when nodes show up in a context menu. For example Dialogue Choice nodes can be configured to only be placed from a Dialogue Node.
Custom transition classes can be automatically placed as well depending on which states are being connected.
Added bEvalWithTransitions to conduits. This allows them to behave similar to anim graph conduits-- They will be treated as a transition and the state you are in won't switch unless the conduit and every connected transition (or connected conduits) pass.
Local conduit graphs now support the general helper nodes available in other graphs.
State machine instances are able to automatically manage delta seconds if nothing is passed in during an Update call, such as from manual tick handling or using the new autobinding transition events. This requires the context have a valid world.
States can disable transition tick evaluation with bDisableTickTransitionEvaluation.
Transitions can disable tick evaluation while allowing auto-binded events to still be processed.
Transitions now allow multiple Initialize and Shutdown Nodes.
The old On State Machine Start node for intermediate reference graphs has been renamed to On Root State Machine Start and is now available for any state type graph.
Added compile validation and additional warnings to help rare cases of state machine children not updating properly when a parent dependency was modified. These are configurable in a new State Machine Project Editor Settings.