Switching to Universal Combat Framework
Documentation Unreal Engine Combat Upgrade
Move a project built on Soulslike Enemy Combat 3.x, Universal Player Combat 1.0 or both onto Universal Combat Framework: turn the standalones off, turn this plugin on, run Finish Switching once, and check the few things it leaves to you.
A project built on Soulslike Enemy Combat 3.x, Universal Player Combat 1.0, or both, moves onto Universal Combat Framework with its assets, settings and names: turn the standalones off, turn this plugin on, and run Finish Switching once.
Every asset, class, property and gameplay tag of the two standalones opens under its new name in this plugin, so your project's assets open as they are and show the new names. Finish Switching then moves the project settings, console variables, component tags and names typed by hand, and resaves every asset of yours that still names a standalone.
Set it up
10 minutes, plus the resave- 1
Print your enemies' weapons
Do your enemies hold weapon Blueprints of your own? An enemy in this plugin holds an item instead, and a weapon Blueprint's settings do not come across. Print them now with the weapon listing and keep the text: after the switch, Weapons: what an enemy holds builds each weapon again from it. The listing reads your project and changes nothing. Skip this step when your enemies hold only the enemy demo's baton, or nothing: the baton is an item here already (An enemy that held the demo's baton). - 2
Back the project up
Commit it to source control, or copy the project folder. Finish Switching saves many assets and config files at once, and asks you to confirm before it starts.Changed an asset inside a standalone's own folder, such as a demo action set tuned in place? Duplicate it into your project's Content first. Your project's references move to this plugin's own copy, which carries the shipped values. Do the same for a demo asset this plugin leaves out that your project uses. - 3
Turn the standalones off and this plugin on
Install Universal Combat Framework: bought on Fab, click Install to Engine in the Epic Games Launcher; claimed as the owner of both standalones, install the release you downloaded as its notes say (Upgrade and access). Then, in the project, open Edit > Plugins: untick Soulslike Enemy Combat and Universal Player Combat, whichever the project has, tick Universal Combat Framework, and restart when prompted.A project runs one or the other, so leave neither standalone on beside it. A project with C++ of its own changes its module names first, or the editor cannot build it: see A project with C++ of its own at the end of this page. - 4
Open the project
The editor opens your project with its assets as they were. Names read the new way: SEC Vitals is UCF Vitals,SEC.Role.AttackerisUCF.Role.Attacker,BP_SEC_EnemyCharacterisBP_UCF_EnemyCharacter.Did an enemy of yours hold a weapon? Then the Message Log also opens on its Load Errors page, naming the weapon classes that have no counterpart here. Weapons: what an enemy holds lists the lines, and Finish Switching clears them. - 5
Run Finish Switching
Open the Tools menu, pick Finish Switching under its Universal Combat Framework heading, and confirm. It works through three stages: moving settings and console variables, finding the assets that name either standalone, and resaving them. When it ends, the Message Log opens on its Universal Combat Framework page with a count of what it moved, renamed and resaved. - 6
Restart and play
Restart the editor so the moved settings and console variables load, then press Play. Go through Check by hand below for anything your project uses.
From one standalone or both
The steps are the same whichever standalone a project started on. What changes is what it finds on the other side.
| The project started on | What to know |
|---|---|
| Soulslike Enemy Combat alone | Your enemies, their data assets and their settings carry over as they are. The enemy demo's player, its controller, game mode and keys open as the player layer's demo player, and the enemy demo's map as LVL_UCF_Demo (below). An enemy that held a weapon holds nothing until you give it an item (Weapons), which reparents it onto UCF Enemy Character Base, so the player layer's lock-on picks it too. An Animation Blueprint the AI agent tools made for an enemy needs its template kept first (below). |
| Universal Player Combat alone | Your player, items, action graphs and settings carry over as they are. The player demo's enemies do not: its behavior tree enemy, attack tokens and two of its bosses are left out, and its weak enemy and first boss open as the enemy layer's demo enemy and boss, which run the enemy AI. |
| Both | Everything above. Tags both carried under one name are one tag here, so a rule that reads one reads it on enemies and players alike (below). Your player and your enemies take each other's hits through their own damage handling, the enemy's block and parry rules and its reactions included, where the two standalones met only through Unreal's point damage: an Event AnyDamage you wired to carry those hits is no longer called for them, and no hit counts twice. A console variable or log category both standalones set under their own names is one name here; Finish Switching keeps one value and the Message Log names the one it dropped. |
What carries over
| What | Example | What to do |
|---|---|---|
| Assets, Blueprints and levels | BP_SEC_EnemyCharacter opens as BP_UCF_EnemyCharacter, Item_UPC_Sword as Item_UCF_Sword | Nothing. Finish Switching resaves your own assets that point at them. |
| Classes, components and their properties | SEC Vitals is UCF Vitals, UPC Action Graph is UCF Action Graph | Nothing. The enemy layer's types without a prefix keep their names: Action Set, Enemy Character Base, Enemy AI Config, the StateTree tasks. |
| Gameplay tags in assets and Blueprint tag pins | SEC.Role.Attacker is UCF.Role.Attacker | Nothing. Finish Switching rewrites the tags typed into gameplay tag pins and reconnects the wires of a Switch on Gameplay Tag whose cases name them. |
| Project settings | Soulslike Enemy Combat is Universal Combat Framework Enemy under Project Settings, Plugins | Nothing. Finish Switching moves each section (table below). |
| Console variables and log levels set in config | SEC.Debug.All is UCF.Debug.All, LogUPCDamage is LogUCFDamage | Nothing, for the Engine, Game and Editor configs. Device profiles are by hand (below). |
| Component tags | UPC.Montage is UCF.Montage, UPC.Attachment.Body is UCF.Attachment.Body | Nothing. Finish Switching renames them on every component. |
| Warp target names, blackboard keys and names typed into Name pins | UPCTarget is UCFTarget, SEC_TargetActor is UCF_TargetActor | Nothing. Finish Switching renames a name that matches one exactly. |
| Events a placed actor binds on its components | A demo door placed in one of your levels, whose Blueprint handles its interactable's events | Nothing. Finish Switching binds each event again where the Blueprint's handler took a new name. |
| Values in the standalones' own structs | A walk animation set on an animation layer | Nothing. Each value lands in its new field. |
Some tags both standalones carried under one name are one tag here, such as
UCF.State.Blocking, UCF.Vital.Health and UCF.AnimEffect.Footstep. A rule that reads one of them reads it on enemies and players alike. Names in Universal Combat Framework lists them, with every old name beside its new one.Project settings
Each section moves under Project Settings > Plugins with the values you set.
| Before | After |
|---|---|
| Soulslike Enemy Combat | Universal Combat Framework Enemy |
| Soulslike Enemy Combat Demo | Universal Combat Framework Demo |
| Universal Player Combat | Universal Combat Framework |
| Universal Player Combat Demo | Universal Combat Framework Demo |
| Universal Player Combat Input Display | Universal Combat Framework Input Display |
| Universal Player Combat Editor | Universal Combat Framework Editor |
| Universal Player Combat Pairing Editor | Universal Combat Framework Pairing Editor |
The two demo sections become one. Where both set Load Demo Hit Effects to different values, Finish Switching keeps one, and the Message Log names the value it dropped; set it by hand if the dropped one is the one you want. With it off and no gameplay cue folder of your own, the Output Log warns
No GameplayCueNotifyPaths were specified as Play starts, and the demo's hit effects do not play.Demo content that lands elsewhere
This plugin carries one demo,
LVL_UCF_Demo, with one demo player and the enemy layer's enemies. A reference to these demo assets of the standalones opens on the asset beside them:| Before | Opens as |
|---|---|
LVL_SEC_Demo, LVL_UPC_Demo | LVL_UCF_Demo |
LVL_UPC_Demo_Enemies | LVL_UCF_Demo_Enemies |
The enemy demo's player: BP_SEC_PlayerCharacter, BP_SEC_PlayerController, BP_SEC_GameMode, IMC_SEC_Default | The player layer's: BP_UCF_Character, BP_UCF_PlayerController, BP_UCF_GameMode, IMC_UCF_Default |
IA_SEC_Attack, IA_SEC_Dash, IA_SEC_Interact, IA_SEC_Look, IA_SEC_Move | IA_UCF_LightAttack, IA_UCF_Dash, IA_UCF_Interact, IA_UCF_Look, IA_UCF_Move |
BP_SEC_EnemyCharacter, BP_UPC_Enemy_Weak | BP_UCF_EnemyCharacter, the demo enemy, which holds its baton as an item |
BP_SEC_BossCharacter, BP_UPC_Boss | BP_UCF_BossCharacter, the demo boss |
The enemy demo's baton moves: AM_SEC_TwoHanded_SingleAttack, _DoubleAttack, _TripleAttack, _Block | The player layer's baton moves: AM_UCF_TwoHanded_SingleAttack, _DoubleAttack, _TripleAttack, _Block |
Damage_SEC_TwoHanded, Damage_SEC_Unarmed | Damage_UCF_TwoHanded, Damage_UCF_Unarmed, the player layer's baton and fist damage |
DefenseRuleSet_SEC_TwoHanded | DefenseRuleSet_UCF_TwoHanded, the baton's block and parry |
GA_SEC_TwoHanded_Shoot | GA_UCF_TwoHanded_Shoot, which throws from the item the enemy holds |
BP_SEC_WeaponBase | BP_UCF_WeaponBase, the player layer's weapon base |
NS_SEC_WeaponTrail, MI_SEC_WeaponTrail_Default | NS_UCF_WeaponTrail, MI_UCF_WeaponTrail_Default |
BP_SEC_Dummy, BP_UPC_Dummy | BP_UCF_Dummy, one training dummy for both |
WBP_SEC_HUD_Encounter, WBP_UPC_BossBar | WBP_UCF_EncounterBar, one boss bar that shows for the whole fight |
| The enemy demo's sounds | The player layer's sounds made from the same recordings |
| The enemy demo's animation family | The player layer's one family (below) |
A Blueprint of your own made from either demo's enemy or boss becomes a child of this plugin's demo enemy or boss, which runs the enemy AI and holds its weapon through its Loadout (Weapons).
Demo content this plugin leaves out
These demo assets have nothing to open as. A reference to one opens empty, and a Blueprint made from one loses its parent. Duplicate any your project uses into its Content before you switch, together with the assets it uses from this list.
- From the enemy demo: the demo player's dash,
GA_SEC_PlayerDash, and its unarmed montages,AM_SEC_Unarmed_ComboandAM_SEC_Unarmed_Dodge; the demo's own widgets (WBP_SEC_DemoPanel,WBP_SEC_LimitSlider,WBP_SEC_ScreenGuide_Player,WBP_SEC_Toggle,WBP_SEC_AwarenessState) andBP_SEC_GameState; its baton Blueprint,BP_SEC_TwoHandedBaton, since enemies hold the baton item,Item_UCF_TwoHandedBaton; its environment level,LVL_SEC_Environment; the locomotion template the AI agent tools build from,ABP_SEC_LocomotionTemplate, with its locomotion animations. - From the player demo: the behavior tree enemy,
BP_UPC_Enemy, with its controller,BT_UPC_Enemy,BB_UPC_Enemy, the tasks and service it runs (BTT_UPC_Attack,BTT_UPC_RequestToken,BTT_UPC_Strafe,BTS_UPC_FindTarget), the attack token poolBP_UPC_AttackTokensand its ability setAbilitySet_UPC_Enemy; and two bosses,BP_UPC_Boss_SmallandBP_UPC_Boss_Soulslike.
Weapons: what an enemy holds
In this plugin an enemy holds items, the same items the player draws: its UCF Equipment Manager draws them, and its UCF Enemy Loadout lists what it starts holding and which moves its AI takes for each. The enemy layer's weapon classes have no counterpart: SEC Equipment Component, SEC Weapon Base, the weapon set interfaces and SEC Equip Statics. So after the switch, an enemy that held a weapon holds nothing, and a weapon Blueprint of yours opens without its weapon settings. Build each weapon again as an item from what the weapon listing printed, and hand the item to the enemy.
Until you do, the Output Log names what lost its class, as the project opens and as Finish Switching resaves it:
Failed to load Class /Script/UCFEnemy.SECWeaponBase as Parent for BlueprintGeneratedClasson each weapon Blueprint of yours, and a compile of it reportshas missing or NULL parent class. The steps below delete it, or reparent it.Unable to load EquipmentComponent ... because its class (SECEquipmentComponent) does not existon each enemy Blueprint that held a weapon. Finish Switching resaves the enemy without the component, and the line does not come back.- On the Message Log's Load Errors page as the project opens:
a dependent package /SoulslikeEnemyCombat/Demo/Weapons/TwoHanded/BP_SEC_TwoHandedBaton was not availablefor an enemy that held the enemy demo's baton, and aCreateExport: Failed to load Outer for resourceline for each part of a weapon Blueprint of yours. The page stays empty once Finish Switching has run. FMemberReference::ResolveMember (SetTrailActive) bSelfContext == true, but no scope supplied!, and the same forSetLifeSpan, while a weapon Blueprint made from the enemy demo's weapon base loads. They go with that Blueprint.- In Play, the first time an enemy with nothing in its hand swings:
Trace socket 'Baton' is not registered on ...andTrace window on ... has no socket left to trace. Its attack montages trace the weapon's sockets, which the item registers once the enemy holds it.
The weapon listing
Run it before the switch, in the project as it stands. Turn on Python Editor Script Plugin under Edit > Plugins if it is off, save the script below as
list_weapons.py, and run it with File > Execute Python Script. The Output Log shows a WEAPON block for each weapon Blueprint, with its mesh, its attach socket and offset, its animation layer, its weapon sets and each trace socket, and a LOADOUT line for each entry of each enemy's Starting Loadout. Copy the lines into a text file.Pythonlist_weapons.py
import unreal
registry = unreal.AssetRegistryHelpers.get_asset_registry()
subobjects = unreal.get_engine_subsystem(unreal.SubobjectDataSubsystem)
library = unreal.SubobjectDataBlueprintFunctionLibrary
weapon_base = unreal.SECWeaponBase # https://rigbak.com/docs/soulslike-combat/weapons
equipment = unreal.SECEquipmentComponent # https://rigbak.com/docs/soulslike-combat/weapons
def name(value):
if value is None:
return "None"
if hasattr(value, "get_path_name"):
return value.get_path_name()
if hasattr(value, "export_text"):
return value.export_text()
return str(value)
def components(blueprint):
found = {}
for handle in subobjects.k2_gather_subobject_data_for_blueprint(blueprint):
component = library.get_object(library.get_data(handle))
if isinstance(component, unreal.ActorComponent):
found.setdefault(component.get_name(), component)
return list(found.values())
for asset in registry.get_assets_by_path("/Game", recursive=True):
if str(asset.asset_class_path.asset_name) != "Blueprint":
continue
blueprint = asset.get_asset()
generated = blueprint.generated_class() if blueprint else None
if generated is None:
continue
defaults = unreal.get_default_object(generated)
parts = components(blueprint)
if isinstance(defaults, weapon_base):
print(f"WEAPON {blueprint.get_path_name()}")
for part in parts:
if isinstance(part, unreal.StaticMeshComponent):
print(f" Mesh ({part.get_name()}): {name(part.get_editor_property('StaticMesh'))}")
elif isinstance(part, unreal.SkeletalMeshComponent):
print(f" Mesh ({part.get_name()}): {name(part.get_editor_property('SkeletalMeshAsset'))}")
for field in ("AttachSocket", "AttachOffset", "AnimLayerToUse", "WeaponActionSet", "WeaponReactionSet", "WeaponDefenseSet"):
print(f" {field}: {name(defaults.get_editor_property(field))}")
for socket in defaults.get_editor_property("TraceSockets"):
print(f" TraceSockets: {socket.export_text()}")
native = defaults.get_component_by_class(equipment)
for part in [native] + [p for p in parts if not native or p.get_name() != native.get_name()]:
if isinstance(part, equipment):
for entry in part.get_editor_property("StartingLoadout"):
print(f"LOADOUT {blueprint.get_path_name()}: {entry.export_text()}")Make each weapon an item
Right-click in the Content Browser, pick UCF > Items > Item Definition, and name it after the weapon (
Item_Greatsword for BP_Greatsword). Add its fragments under Fragments and fill them from the weapon's WEAPON block:| The listing's line | On the item |
|---|---|
Mesh | A Visuals fragment: Mesh. |
AttachSocket | Nothing for hand_r: the enemy's Equipment Manager puts the main hand there (Body Places). For another socket, set Body Socket Override on the Hold Places row below. |
AttachOffset | An Equippable fragment: a Hold Places row with Place UCF.Place.Main and this Offset. A two-handed weapon also takes a UCF.Place.Off row with the same offset, and Places Required 2. |
TraceSockets | Equippable: a Trace Sockets row for each, with the same ID, shape, sockets and radius, and Source Component Tag UCF.ItemMesh, the item's mesh in the hand. Keep the ID your attack montages' UCF Melee Trace Windows list in Socket IDs; the demo's two-handed moves list Baton. |
AnimLayerToUse | Equippable: Anim Layer Class. A layer from the enemy demo opens under its new name: ABP_SEC_TwoHanded is ABP_UCF_TwoHandedAnimLayer. |
bUseAsWeapon on its LOADOUT line | Equippable: Main Weapon on, so the item drives the enemy's moves; off for an item held beside the weapon. Saving an item with Main Weapon on and no Action Graph logs Main Weapon is on but no Action Graph is set: the warning speaks for a player, whose moves come from the graph, and an enemy takes its moves from the Item Sets row below, so leave the graph empty for an item only enemies hold. |
WeaponDefenseSet | A Guard fragment: Defense Set. |
WeaponActionSet, WeaponReactionSet | The enemy's Item Sets row, below. |
| The demo weapon base's trail | A Swing Trail fragment, its Trail System NS_UCF_WeaponTrail. |
| Drop Weapon On Death, on the enemy's Combat Controller | Stays there. Add a World Item fragment so the item drops as something a player picks up; without one it is put away at death. |
| The enemy's Drop Lifetime | No counterpart: a dropped item lies until someone takes it. |
Give the item to the enemy
- Reparent the enemy Blueprint onto UCF Enemy Character Base with File > Reparent Blueprint. It brings the Equipment Manager, the Loadout, the player layer's melee trace and UCF Anim Manager, and what Enemies on Enemy Character Base describes. Its AI Config, action and reaction sets and every other setting stay.
- On its Loadout, put the item in Starting Items, one entry for each of its
LOADOUTlines, in their order. - On the Loadout, add an Item Sets row: Item the item, Action Set the weapon's
WeaponActionSet, Reaction Set itsWeaponReactionSet. A weapon Blueprint that gave each combat role its own set takes a row for each, with its Combat Role. - For flinches, staggers and a limp fall at death: set Reaction Set on its Physical Reaction component (the demo's
PhysReact_UCF_Enemy), Bank on its Anim Effects component (AnimEffectBank_UCF_Default), and addGA_UCF_HitReact,GA_UCF_StunandGA_UCF_ParryRecoilto its Starting Abilities; the last makes it recoil when the player parries it. - Delete the weapon Blueprint once its item holds its values. A weapon Blueprint with logic of its own stays: open it, answer Yes when the editor says it derives from an invalid class, and reparent it onto
BP_UCF_WeaponBasewith File > Reparent Blueprint. The compile then lists the old base's events and members as missing, such as Event On Equipped and Event On Unequipped: move their work to On Drawn and On Stowed and delete the old nodes. Add the component tagUCF.ItemMeshto the mesh its trace sockets ride, and name the Blueprint on the Equippable fragment as Item Actor Class.
Check: in Play the enemy draws the item into its hand, closes in, swings and lands its hits, answers your swings with the reactions its Item Sets row names, and drops the item at death.
An enemy that held the demo's baton
The enemy demo's baton is an item here already,
Item_UCF_TwoHandedBaton, so there is nothing to build or delete. Follow Give the item to the enemy with it: put it in Starting Items, and give its Item Sets row the Reaction Set ReactionSet_UCF_TwoHanded, the baton's reactions under their new name, and no Action Set, as the demo enemy BP_UCF_EnemyCharacter's Loadout does. The baton brings its own block and parry rules, mesh, trace socket and trail.Blueprint and C++ calls
| Enemy layer | This plugin, on the enemy's Equipment Manager |
|---|---|
| Equip Actor, and the SEC Equip Statics nodes | Equip Item (UUCFEquipmentManagerComponent::EquipItem), naming an item |
| Unequip Actor | Unequip Item |
| Get Equipped Weapon | Get Combat Driver Instance, then Get Spawned Actor for the item's actor in the hand |
| On Equipped Weapon Changed | On Combat Driver Changed |
Check by hand
Finish Switching leaves these to you. Each one applies only if your project uses it.
Primary asset types in the Asset Manager
If Primary Asset Types to Scan, under Project Settings > Game > Asset Manager, has an entry whose Primary Asset Type is
SECAwarenessConfig, UPCAbilitySet, UPCItemDefinition or UPCPairedAction, rename it to UCFAwarenessConfig, UCFAbilitySet, UCFItemDefinition or UCFPairedAction. Enemies on Enemy Character Base
An enemy Blueprint built directly on Enemy Character Base, or a C++ class derived from it, has nothing the player's targeting can pick or lock on to, and holds no item. Reparent it onto UCF Enemy Character Base (File > Reparent Blueprint), as Weapons does for an armed enemy, or add a UCF Enemy Targetable component to it; either lets the player lock on to it and lets go when it dies. A Blueprint of the enemy demo's enemy or boss already has it. The new parent also brings UCF Enemy Attack Steering, which aims the attacks an enemy plays from an action graph at the target its AI fights; an enemy that keeps its old parent and plays action graph combos takes that component too. On the new parent the melee trace starts on Enemies Only, so a reparented enemy's swings pass over its teammates unless its Team Filter was set; set it to No Filter for an enemy that hits everyone.
Animation Blueprints on the enemy demo's animation family
The enemy demo's Animation Blueprints, layer interface and animation types open as the one family every character in this plugin runs:
ABP_UCF_MannequinBase, ALI_UCF_ItemAnimLayers, ABP_UCF_ItemAnimLayersBase, ABP_UCF_TwoHandedAnimLayer, ABP_UCF_UnarmedAnimLayers, E_UCF_CardinalDirection and F_UCF_CardinalSet. An Animation Blueprint of your own built on them keeps its animation sets. Open it, compile it, and fix any layer or variable the compiler reports.Two variables of the enemy demo's family have no counterpart: Orientation Angle Smoothed and Walk Cardinal Angle Offsets. A Blueprint reading either one stops compiling until that read is removed.
Animation Blueprints made from the enemy layer's locomotion template
An Animation Blueprint the AI agent tools made for an enemy is a child of
ABP_SEC_LocomotionTemplate, which this plugin leaves out. Before you switch, duplicate the template and the locomotion animations it plays into your project's Content, and reparent your Animation Blueprint onto the copy (File > Reparent Blueprint). The player layer's template, ABP_UCF_LocomotionTemplate, has other variables than the enemy layer's, so keep the copy as your Blueprint's parent. Training dummies placed in a level
The enemy demo's training dummy opens as the player layer's dummy, a character, so a dummy you placed in a level of your own shows half sunk into the floor in the editor, its capsule's center on the point its base stood on. Play lifts it out of a solid floor, but the level keeps the sunk spot: move it up, or place it again.
Console commands and tags typed as text
Finish Switching renames names held as names and tags held as tags. Text in a String or Text (an Execute Console Command node's command, a widget showing a tag) keeps the old words: rename them by the table in Names in Universal Combat Framework. Most only change their prefix. These take
Enemy instead: SEC.Debug.ActionsisUCF.Debug.EnemyActions, sinceUCF.Debug.Actionsis the action graph's overlay.LogSoulslikeEnemyCombatisLogUCFEnemy.LogSECEquipmenthas no counterpart: an enemy's items log underLogUCFEquipment, as the player's do.- The hit cue tags under
GameplayCue.SEC.Hitsit underGameplayCue.UCF.Enemy.Hit.
Gameplay tags your project added
A gameplay tag your project defined itself under the standalones' tag roots keeps its name and keeps working. To move it under
UCF, rename it in Project Settings > Gameplay Tags.Folder paths in project settings
A folder path that points inside a standalone's content, such as a directory the Asset Manager scans or a gameplay cue path in
DefaultGame.ini, keeps the old folder. Point it at the same folder in this plugin's content: the folders keep their layout, so /SoulslikeEnemyCombat/Demo/AI is /UniversalCombatFramework/Demo/AI. A map or game mode set in Maps & Modes loads under its new name; pick it again to store the new one. Plugins of your own
A plugin in your project that lists Soulslike Enemy Combat or Universal Player Combat among the plugins it depends on (the Plugins list in its
.uplugin file) names UniversalCombatFramework there instead.Console variables in device profiles
A console variable set on a device profile (a
+CVars= line in DefaultDeviceProfiles.ini or a platform's device profile config) keeps its old name. Rename it by the same table.Names in a Set or a Map key
A name stored as an element of a Set, or as the key of a Map, in a Blueprint variable or a data asset keeps its old text. Edit it by hand.
Event dispatcher pins
A pin typed with one of the standalones' event signatures rebuilds itself from the event it is bound to when its node is refreshed. If a node still shows an error after Finish Switching, right-click it and pick Refresh Node, then compile.
A deterministic enemy's seed
A deterministic enemy plays a different fight from the same seed after switching. The same seed still gives the same fight every time in this plugin, so pick and record your seeds again once.
AdvancedWhat Finish Switching changes, in full
- Config files. In the project's Default configs and every platform config, each standalone settings section moves to its new name, values included; a value holding an old component tag, name or gameplay tag is renamed with it. A section whose new name the file already holds joins it, keeping the value already there where both set one, and the Message Log warns about each value dropped. Console variables and log categories set in the Engine, Game and Editor configs take their new names. Where one section sets one of them under two old names, as a project on both standalones can (
SEC.Debug.MaxDistanceandUPC.Debug.MaxDistanceare bothUCF.Debug.MaxDistance,LogSECDamageandLogUPCDamagebothLogUCFDamage), it keeps the line already under the new name, else the first, and the Message Log warns about each value dropped. A file under source control is checked out first; a read-only file is reported and left as it is. - Assets. It reads every asset in the project's Content folder and in each of the project's own plugins (this plugin's own content left out), and loads, fixes and saves each one whose saved data still names a standalone's module, content or tags. In each one it renames component tags, warp target names, blackboard keys, primary asset type names and Name pins holding exactly an old name. A tag read by prefix (
UPC.Attachment,UPC.Montage,UPC.AnimLayer) has only that prefix renamed, soUPC.Attachment.BodybecomesUCF.Attachment.Body. Gameplay tags typed into tag pins take their new names. - Blueprint wires. A Switch on Gameplay Tag whose cases name renamed tags, or a Switch on Name whose cases name renamed names, loses the wires on those cases as it loads under the new names. Finish Switching rebuilds the node and wires each case again as the asset's saved file had it. It compiles the Blueprints of each asset it changed before saving, so a packaged game plays the fixed graph.
- Placed actors. Where a placed actor's Blueprint handles a component's event under a new function name, it drops the old binding and binds the event again.
- Report. An asset that does not load is named in the Message Log as an error; open it, fix what the log reports, and run Finish Switching again. A second run renames whatever is still old, and may load and save some assets again with nothing left to change.
AdvancedFinishing chosen assets from a script
Rename Switched Names (Blueprint callable, under Universal Combat Framework, Switching) renames the component tags and names in every object of one loaded asset and the gameplay tags typed into its Blueprint pins, wires again each Blueprint link a renamed pin lost, binds each placed actor's component events again, and returns how many it changed. Compile the asset's Blueprints and save the package afterwards. Use it in an editor utility or a Python script to finish switching assets one at a time.
C++A project with C++ of its own
Change the code before you reopen the editor, since the project's module has to build against this plugin. Each old name has one new name; Names in Universal Combat Framework lists them all.
- Build.cs. Replace each module dependency:
SoulslikeEnemyCombatwithUCFEnemy,SECCorewithUCFCore,SECMotionwithUCFMotion,SECEditorwithUCFEnemyEditor, and eachUPC<Module>withUCF<Module>(UPCActionswithUCFActions). - Includes and types. File and type names change prefix the same way:
Components/SECVitalsComponent.hisComponents/UCFVitalsComponent.h,USECVitalsComponentisUUCFVitalsComponent,UUPCActionGraphComponentisUUCFActionGraphComponent. The enemy layer's types without a prefix (UActionSet,AEnemyCharacterBase,FActionSpec) keep their names. - Names the two standalones shared. Where both had a type of one name, the enemy layer's takes
Enemyafter the prefix:ESECActionEndReasonisEUCFEnemyActionEndReason,USECActionHookisUUCFEnemyActionHook. - Text in code. Gameplay tags requested by name, console variable names and log categories in your source change with the table too (
LogSECDamageisLogUCFDamage). - To give an enemy class the player's lock-on, derive from
AUCFEnemyCharacterBaseor create aUUCFEnemyTargetableComponenton it. The base also creates aUUCFEnemyAttackSteeringComponent, which aims the enemy's action graph attacks. - Code that called the enemy layer's weapon classes (
USECEquipmentComponent,ASECWeaponBase,USECEquipStatics) calls the enemy'sUUCFEquipmentManagerComponentinstead, as the calls table lists; those classes have no counterpart in this plugin.