Doc. AB-2.0Field manual · Unreal Engine 5.8Rev. 5d605e012 · 10 · 2026

AbleGeneration 2.0

Richer abilities. Clearer authoring. More control over every execution.

A visual tour of our custom Able: collision shapes, multiple phases, reactive gameplay, persistent state, and weapon integration.

Built on Able 3.96 for Unreal Engine 5.8. “Generation 2.0” names this project's evolution.

Read the contents View the source repository

Fig. 00 Ground Slam, one of the project's Collision Shapes, as the Shape Preview measures it.

01Shape the attack8 fig.Able Collision Engine — hitboxes that match the move.
02Give one ability several phases3 fig.Wind up. Sustain. Recover. Keep one execution.
03React when gameplay happens3 fig.Typed gameplay events — respond to a result, instead of guessing its timing.
04Remember between activations2 fig.Ability State — structured memory for each caster.
05Keep each player's effects independent3 fig.Passives per instigator — separate stacks, expiry and attribution.
06Make input part of the move1 fig.Enhanced Input — hold, release and branch with Input Actions.
07Author the movement4 fig.Root-motion tasks — dashes, pulls, knockbacks and leaps.
08Read the ability at a glance1 fig.Ability Editor — clearer tracks, phase routes and preview controls.
09Bind it. Spawn it. Present it.3 fig.Richer task authoring — customize each use of the move.
10Make collision cheaper—and visible1 fig.Native shape execution, caching and ACE Profiler.
11Start abilities. Follow the result.2 fig.Simpler APIs and leaner replication underneath.
12Connect the weapon to the move4 fig.EasyBallistics and bindable execution contexts.
00The foundation underneath2 fig.Optional test tooling. Clearer plugin boundaries. No compatibility code left.

Browse the images. Open Look closer for the controls behind them. On the website, click any image to enlarge it.

Each Look closer panel includes a compact code directory. File links open the private development repo at revision 5d605e0 (12 October 2026), so the line numbers stay fixed. Repository access is required to open the source.

13 chapters · 37 figures.

§01

Figures: 8
Source files: 13

Chapter 01

Shape the attack

Able Collision Engine — hitboxes that match the move.

Build reusable Collision Shapes from presets, outlines, and repeated pieces. Preview the volume beside its graph, drag its dimensions into place, and expose them through typed Params.

Cross Slash's construction graph, live shape preview and parameter controls. — Cross Slash: build the arc, inspect the volume, adjust its dimensions.

Ground Slam's Arc Shape node selected: Outer Radius, Height, Angle and Location handles on the ring, its inputs in Details. — **Handles:** select a node, then drag its radius, height, angle or location.

Cross Slash's Transform Hulls in Details: Transform traced to Make Transform, Rotation to Make Rotator, X (Roll) as the Tilt Param. — **Details:** follow a wire back to the Param behind it.

Look closer: handles, Details, ranges and abilities

Cross Slash's Generate Arc Points selected: its points drawn along the arc, with Radius, Angle and Center handles. — **Generate Arc Points:** points, with Radius, Angle and Center handles.

GrenadeExplosion's Collision Query: a Sphere Shape of radius 500 in the Ability Editor viewport, with its location gizmo. — **GrenadeExplosion:** a Sphere Shape query, drawn and placed in the viewport.

Cross Slash preview with debug points and viewport parameter handles. — **Cross Slash:** debug a node and drag its handles.

Morning Star composed from a sphere and repeated cone spikes. — **Morning Star:** reuse and repeat smaller pieces.

Collision Query exposes Cross Slash's Radius, Thickness, Angle, Height and Tilt with separate binding controls. — Bind one dimension without replacing the whole parameter struct.

Handles: a drag writes the value where it lives: the pin's own value, or the Param it's wired from. Each drag is one undo; values computed by other nodes aren't draggable.
Node Details: a selected node's inputs edit as on the node. Inputs from Get Shape Params name their Param, "X (Roll) (Tilt Param)"; inputs from other nodes fold out into those nodes' inputs, up to four nodes back, with lists folded.
Ranges: a Params member's Value Range clamps every build, so a random 0 can't reach Build Shape. The Preview names each clamp.
Presets: Box, Sphere, Capsule, Segment, Cylinder, Cone, Vision Cone, Arc, Dome, Star, Prism and Path.
Construction: Hull, Extrude and Revolve; concave outlines split into convex pieces. Polygon, Rectangle, Star and Arc generators supply outlines.
Composition: Merge, Transform, Duplicate, Repeat, Mirror and nested Shapes. Blueprint and native C++ share the building blocks.
Inspection: coloured hulls with the node that made each, points, dimensions, warnings, D to see one node's output, and a preview that rebuilds as you edit.
Integration: Query, Sweep, Watch for Overlap and targeting; negative query shapes, automatic range and per-field bindings. Ordinary Blueprint queries support typed Params and async completion.

Async completion returns to the game thread. Worker-safe shapes can also build off-thread; raycasts retain line-trace behavior.

Parts list · Source path key

What to find	File · line
Preset volumes	AblPresetShapes.cpp · L13 _{ACE · Private/Shape}
Hull, outline and composition nodes	AblCustomShapeNodes.cpp · L46 _{ACE · Private/Shape}
Concave outline decomposition	AblShapeBuildPolygons.cpp · L110 _{ACE · Private/Build}
Ability query integration and Params	ablCollisionShapes.cpp · L11 _{AbleCore · Private}
Per-field value bindings	ablMemberBindings.cpp · L91 _{AbleCore · Private}
Typed Blueprint query pins	K2Node_AblShapeQuery.cpp · L217 _{ACE Graph · Private}
Viewport node handles	AblShapeNodeHandles.cpp · L282 _{ACE Editor · Private/Preview}
Node Details, traced through wires	AblShapeNodeDetails.cpp · L206 _{ACE Editor · Private/Blueprint}
Details for the selected node	AblShapeNodeSelection.cpp · L36 _{ACE Editor · Private/ShapeEditor}
A value written where it lives	AblShapePinValues.cpp · L213 _{ACE Editor · Private/Preview}
Generator handles	AblGeneratorHandles.cpp · L7 _{ACE Editor · Private/Preview}
Params kept in range	AblShapeParamsLimits.cpp · L67 _{ACE · Private/Shape}
Create Params Struct	AblShapeEditorUtils.cpp · L84 _{ACE Editor · Private/Blueprint}

§02

Figures: 3
Source files: 6

Chapter 02

Give one ability several phases

Wind up. Sustain. Recover. Keep one execution.

Each timeline owns its tasks, playback, loops and exit routes. Phase transitions preserve the running context; alternate attacks can also own separate cooldowns and targeting.

Wind Up, Sustained Attack and Recovery tabs show the routes between phases. — The phase tabs show what runs next.

Look closer: held loops and independent attacks

Sustained Attack loops and routes to Recovery when its input channel fails. — **Channel failure → Recovery.**

A timeline owns a three-second cooldown and Cross Slash targeting with automatic range. — **Own cooldown, target requirement and shape.**

Bind playback, loop count and destinations; route completion and channel failure separately.
Choose a starting phase, find one by name, or pick random/weighted destinations using shared random values.
Targets, stacks and scratchpads survive transitions. Tasks end with Branched; activation checks and cooldowns are not repeated.
Add, rename, duplicate, reorder or remove phases; stable identities retain their tasks. Dependencies stay within a timeline.

Parts list · Source path key

What to find	File · line
Phase settings and defaults	ablAbilityTimeline.cpp · L11 _{AbleCore · Private}
Transition, retained context and task queues	ablAbilityInstance.cpp · L1118 _{AbleCore · Private}
Completion and channel-failure routes	ablAbilityInstance.cpp · L343 _{AbleCore · Private}
Request a phase; random destinations below	ablAbilityContext.cpp · L348 _{AbleCore · Private}
Per-phase targeting; cooldown keys below	ablAbility.cpp · L587 _{AbleCore · Private}
Tabs, routes and phase actions	SAbilityTimelineSelector.cpp · L135 _{AbleEditor · Private/AbilityEditor}

§03

Figures: 3
Source files: 6

Chapter 03

React when gameplay happens

Typed gameplay events — respond to a result, instead of guessing its timing.

Tags declare payload types. Send and Get Payload expose those types in Blueprint; Listen tasks release response groups when a matching event arrives.

Typed Send Gameplay Event and Get Gameplay Event Payload nodes expose Scalable Float members from the selected tag. — An existing registry tag supplies the payload type. Split pins expose its members.

Look closer: the registry and repeated responses

The project's Gameplay Event Registry pairs tags with payload structs. — Declare the tag and type once; author with typed pins.

Listen for Gameplay Event uses Repeat, Queue, eight queued responses and a two-second response watchdog. — Listen repeatedly, queue accepted events, and bound how long a response may run.

Publish: Started, Completed, Interrupted, Manual and supported Result events. Damage, spawn, query and committed barrel-shot results carry captured outcomes.
Route: Self, Instigator, Targets or a specified component; combine sources and Blueprint waits across components.
Respond: Once/Repeat, Ignore While Busy/Queue, limits and overflow counts. Dependents use event-relative delay or timeline timing.
Isolate: each response gets its own context and scratchpads; optionally target the event subject. Read captured payload and source metadata.
Bind and diagnose: whole payloads or individual fields, child-tag type inheritance, bounded dispatch, dropped-event counters, trace and clean cancellation.

Gameplay events are local; they do not automatically replicate or activate abilities. Ability Callbacks remain separate.

Parts list · Source path key

What to find	File · line
Tag registry and inherited payload types	ablGameplayEventRegistry.cpp · L21 _{AbleCore · Private/Events}
Routing, dispatch limits and tracing	ablGameplayEventRouter.cpp · L69 _{AbleCore · Private/Events}
Listen windows, sources and cancellation	ablListenEventTask.cpp · L48 _{AbleCore · Private/Tasks}
Response queues and isolated execution	ablEventExecution.cpp · L187 _{AbleCore · Private/Events}
Typed Send node	K2Node_AblSendGameplayEvent.cpp · L39 _{AbleEditor · Private/Blueprint}
Typed Get Payload node	K2Node_AblGetGameplayEventPayload.cpp · L33 _{AbleEditor · Private/Blueprint}

§04

Figures: 2
Source files: 5

Chapter 04

Remember between activations

Ability State — structured memory for each caster.

Keep charges, combo progress or a previous target on the Ability Component. Typed Get/Set nodes expose the selected struct's members.

Get Ability State reads Has Charged, Charges and Combo Step; Set Ability State writes a changed charge count. — Read the caster's values, change one, and retain the others.

Look closer: defaults, sharing and replication

Ability State selects ST Ability Memory, initializes three charges and uses Server replication. — Choose the struct, starting values, sharing key and replication policy together.

Lazy storage: create on first use; Use State can disable storage for selected casters. Has State reports availability.
Shared memory: related abilities share a State Key. Component State Overrides supply different defaults.
Typed updates: Context inside an ability; Component + Ability elsewhere. Leave Unchanged preserves a member without a Set pin; read-only structs use whole-state replacement.
Lifecycle: reset one key or all states; struct/member edits refresh nodes.
Replication: Local per machine, or server-authoritative values sent to the owning client.

Parts list · Source path key

What to find	File · line
Lazy storage, overrides and reset APIs	ablAbilityComponent.cpp · L488 _{AbleCore · Private}
Shared state keys and struct selection	ablAbility.cpp · L82 _{AbleCore · Private}
Replication callbacks and typed Get/Set	ablAbilityState.cpp · L11 _{AbleCore · Private}
Typed pins and Leave Unchanged	K2Node_AblAbilityState.cpp · L428 _{AbleEditor · Private/Blueprint}
State defaults inspector	AblAbilityStateDetails.cpp · L30 _{AbleEditor · Private/AbilityEditor}

§05

Figures: 3
Source files: 4

Chapter 05

Keep each player's effects independent

Passives per instigator — separate stacks, expiry and attribution.

Two players can apply the same Burn to one enemy without sharing its lifetime. Query, change or cancel one instigator's application.

Passive settings use Unique Per Instigator, five maximum stacks and duration refresh on new stacks. — One ability type. A separate passive instance for each instigator.

Look closer: inspect ownership and cancel selectively

Get Passive Instigators and Get Current Stack Count for Passive Ability expose per-instigator query controls. — List the applying actors, then inspect a particular actor's stacks.

Cancel Ability uses Remove One and filters Only Passives From Self. — Remove your own application without clearing somebody else's.

Stacks, duration, decay and cooldowns are independent. APIs accept an optional Instigator; Get Current Passive Abilities lists each ability type once. Replication carries separate instances and stack changes.

Temporary tags are reference-counted: one effect ending keeps Status.Burning while another still owns it. Remove One removes a stack from each affected instance.

Parts list · Source path key

What to find	File · line
Per-instigator activation and stacking	ablAbilityComponent.cpp · L953 _{AbleCore · Private}
Stack queries; instigator listing below	ablAbilityComponent.cpp · L1134 _{AbleCore · Private}
Selective passive and stack cancellation	ablCancelAbilityTask.cpp · L31 _{AbleCore · Private/Tasks}
Temporary-tag reference counting	ablAbilityComponent.cpp · L2662 _{AbleCore · Private}

§06

Figures: 1
Source files: 4

Chapter 06

Make input part of the move

Enhanced Input — hold, release and branch with Input Actions.

Use the activation's Context Input or select a Manual Input. Channel and branch readers listen to trigger callbacks for their execution window.

Enhanced Input channel controls use Context Input, Started and While Input Is Active. — Hold the channel; route to Recovery when input stops.

Look closer: input modes and listening windows

On Input branches remember a callback while other conditions become ready.
While Input Is Active follows the action lifecycle; Until Event Occurs ends on the selected callback, commonly Completed for release.
Choose Started, Ongoing, Triggered, Completed or Canceled. Bind the action/trigger; same-component Branch/Play Ability can inherit Context Input.
Listeners belong to one execution and detach at the window's end, including input-component replacement and lost mappings.

Physical hold/release behavior comes from the game's Input Actions and mapping contexts.

Parts list · Source path key

What to find	File · line
Supported trigger events and active phases	ablInputTypes.cpp · L10 _{AbleCore · Private/Input}
Trigger callbacks, active state and cleanup	ablInputListener.cpp · L80 _{AbleCore · Private/Input}
Hold/release channel conditions	ablChannelingConditions.cpp · L36 _{AbleCore · Private/Channeling}
Latched On Input branch conditions	ablBranchCondition.cpp · L60 _{AbleCore · Private/Tasks}

§07

Figures: 4
Source files: 5

Chapter 07

Author the movement

Root-motion tasks — dashes, pulls, knockbacks and leaps.

Four dedicated tasks use Character Movement sources. Bind values, shape motion with curves, and control how velocity finishes.

Root Motion Radial Force displays its radius and origin gizmo in the viewport beside its settings. — Place the origin. Preview the radius. Author the push or pull.

Look closer: directional force, tracking and jumping

Constant Force exposes direction space, strength-over-time and finish-velocity controls. — Choose the direction space and strength curve for a dash.

Move To exposes destination tracking, stop distance and path curves. — **Move To:** track a destination and stop short.

Jump exposes distance, height and Finish On Landed. — **Jump:** shape the arc and finish on landing.

Task	Main controls
Constant Force	World/Actor/Control Rotation/Control Yaw direction, strength curve, gravity.
Radial Force	Push/pull, moving origin, radius, horizontal force, fixed direction, distance/time falloff.
Move To	Tracking, stop distance, acceptance radius, keep height, path offset/time curves.
Jump	Rotation space, distance, height, path/time curves, minimum landed time.

All share additive/override behavior, priority, source naming, cleanup, finish velocity and temporary movement-mode controls. Duration follows play rate; Move To/Jump can finish early. Character Movement provides source replication, with server and owning-client application by default.

Parts list · Source path key

What to find	File · line
Shared application, finish velocity and cleanup	ablRootMotionTasks.cpp · L93 _{AbleCore · Private/Tasks}
Constant Force source	ablRootMotionTasks.cpp · L380 _{AbleCore · Private/Tasks}
Radial Force source	ablRootMotionTasks.cpp · L441 _{AbleCore · Private/Tasks}
Move To source and destination tracking	ablRootMotionTasks.cpp · L547 _{AbleCore · Private/Tasks}
Jump source and landing behavior	ablRootMotionTasks.cpp · L661 _{AbleCore · Private/Tasks}

§08

Figures: 1
Source files: 6

Chapter 08

Read the ability at a glance

Ability Editor — clearer tracks, phase routes and preview controls.

Task groups separate presentation, collision, damage, movement and reactions. Search and collapse tracks to keep a larger ability readable.

Animation, collision, damage, movement and gameplay-event tasks are separated into timeline groups. — Follow each system's timing without losing the whole move.

Look closer: editing and preview improvements

Organization: named groups, drag reordering, moving tasks between groups and category grouping. Search task/category/group, including collapsed matches.
Navigation: cursor-centred Alt + wheel zoom, Shift + wheel pan, draggable time/frame scrubbing and clearer task bars.
Spatial editing: W/E moves/rotates labelled task gizmos; per-value visibility and one undo per drag. Custom task variables can declare relative space, socket and visibility.
Preview: No Loop, Loop Ability, Loop Timeline, Timeline Once and Force Transition. Faster searchable actor/target pickers, Respawn, Add/Override Target and an initial-timeline new-asset workflow.

Parts list · Source path key

What to find	File · line
Groups, ordering and category organization	ablAbilityEditor.cpp · L590 _{AbleEditor · Private/AbilityEditor}
Task search and track construction	SAbilityTimeline.cpp · L283 _{AbleEditor · Private/AbilityEditor}
Group headers and drag/drop rows	SAbilityTimelineRows.cpp · L274 _{AbleEditor · Private/AbilityEditor}
Cursor-centred zoom and panning	ablAbilityEditor.cpp · L1685 _{AbleEditor · Private/AbilityEditor}
Task gizmo transforms	AblTaskGizmos.cpp · L219 _{AbleEditor · Private/AbilityEditor}
Preview loop modes	ablAbilityEditor.cpp · L2445 _{AbleEditor · Private/AbilityEditor}

§09

Figures: 3
Source files: 5

Chapter 09

Bind it. Spawn it. Present it.

Richer task authoring — customize each use of the move.

Spawn Actor exposes the chosen class's spawn variables with dynamic bindings. Animation and camera-shake controls make presentation easier to configure.

Spawn Actor exposes the Throwable class's bindable Data, Time Cooked and Instigator spawn variables. — The selected class supplies the fields. Bind values for this execution.

Look closer: animation, camera shake and task bindings

Play Animation groups playback, duration, speed and blending controls. — **Animation:** explicit playback, timing and blending.

Nearby camera shake exposes epicenter, radii and falloff controls. — **Camera shake:** nearby players with spatial falloff.

Spawn: class-aware typed variables, defaults/bindings, deferred initialization, attachment and result events.
Animation: playback mode, duration/speed policies, start position, looping, blending, end behavior and migration validation.
Shake: target/nearby recipients, bindable epicenter/radii/falloff, and owned-instance cleanup.
Bindings: broader dynamic values, identifiers and Create/View Binding controls. Effects, sound and ability playback receive supporting authoring/lifecycle improvements.

Smaller completion, cancellation, attachment, damage, turning and cleanup fixes are grouped here rather than listed task by task.

Parts list · Source path key

What to find	File · line
Class-aware spawn fields and deferred values	ablSpawnActorTask.cpp · L354 _{AbleCore · Private/Tasks}
Animation playback and lifecycle	ablPlayAnimationTask.cpp · L91 _{AbleCore · Private/Tasks}
Nearby camera shake and owned instances	ablPlayCameraShakeTask.cpp · L46 _{AbleCore · Private/Tasks}
Dynamic property binding registration	ablAbility.cpp · L476 _{AbleCore · Private}
Create/View Binding editor controls	SAbilityPropertyBinding.cpp · L200 _{AbleEditor · Private/AbilityEditor}

§10

Figures: 1
Source files: 8

Chapter 10

Make collision cheaper—and visible

Native shape execution, caching and ACE Profiler.

Supported shape graphs compile into native execution steps. Geometry reuse and tighter queries reduce repeated work; the profiler separates build and query costs by shape.

ACE Profiler recording three Shape classes: the cost graph with a hover readout, the per-class table, and Worst frames below. — A synthetic test workload: hover the graph to read every line; Worst frames takes the costliest apart.

Look closer: where the savings come from

Native Build Shape: supported math, Params, composition, Branch and Select avoid Blueprint VM dispatch. Unsupported graphs retain the VM with diagnostics.
Reuse: bounded Params caches, shared hulls, cross-build caching and source-change invalidation.
Geometry: faster outline merging, known-face checks and query-only builds; compatible touching pieces can merge on reuse.
Queries: adaptive broadphase, tighter bounds rejection, less scene locking and sweep tests ordered to find earlier blocking hits.
Batches and visibility: worker-thread batches, tunable thresholds, per-shape build/query recording and an engine-sphere comparison baseline.
Worst frames: each class's queries and builds, the slowest of each, the Params that slowest build was for, the game frame's length and hull cache pruning.
Saved recordings: the last five, as a CSV of every frame and a summary; Recordings reopens one in the graph.

Repository A/B measurements cover specific workloads, not a universal speedup. The production profiler is separate from the optional test plugin.

Parts list · Source path key

What to find	File · line
Native shape graph compilation	AblShapeProgramCompiler.cpp · L94 _{ACE Editor · Private/Program}
Native execution steps	AblShapeProgramRunner.cpp · L92 _{ACE · Private/Program}
Params cache and bounded reuse	AblShapeParamsCache.cpp · L94 _{ACE · Private/Shape}
Shared hull cache	AblHullCache.cpp · L54 _{ACE · Private/Geometry}
Adaptive candidate broadphase	AblShapeBroadphase.cpp · L19 _{ACE · Private/Query}
Batch queries and overlap/sweep dispatch	AblCollisionShapeQuery.cpp · L282 _{ACE · Private/Query}
Per-shape cost recording	AblCollisionProfiler.cpp · L202 _{ACE · Private/Profiling}
Profiler window and cost breakdown	SAblCollisionProfiler.cpp · L80 _{ACE Editor · Private/Profiler}

| Saved recordings and summaries | AblProfilerRecordings.cpp · L128
_{ACE · Private/Profiling} | | Worst frames panel | SAblCollisionProfiler.cpp · L558
_{ACE Editor · Private/Profiler} |

§11

Figures: 2
Source files: 5

Chapter 11

Start abilities. Follow the result.

Simpler APIs and leaner replication underneath.

Try Activate Ability creates the context and reports Activated/Failed in one node. Cooldown notifications and adjustments give UI and gameplay direct timer control.

Try Activate Ability exposes Activated, Failed, the created Context and the start result. — Start the selected ability and handle the outcome directly.

Look closer: cooldown controls and networking changes

Change Cooldown and Get Ability Cooldown Remaining expose Timeline Index and Instigator controls. — Adjust a timer in seconds, or read one phase/instigator's remaining time.

Activation: optional instigator, input action, starting timeline and target location. Blueprint and AI can select an attack phase.
Cooldowns: Started/Changed/Ended notifications, remaining seconds and single/all-timer adjustments.
Replication: compact contexts omit implied/default values; project opt-in push model avoids unnecessary comparisons. State uses compact keys for owning-client replication; restarts use normal active-ability replication.
Shared choices: per-visit random Int/Float values support corresponding timeline selections between machines.

Screenshots show the APIs, not network traffic. Gameplay-critical transitions still need server control. Remaining replication limits include same-timeline restarts, passive timeline changes and late-join shared randomness; gameplay events stay local.

Parts list · Source path key

What to find	File · line
Try Activate Ability	ablAbilityComponent.cpp · L803 _{AbleCore · Private}
Cooldown adjustments and notifications	ablAbilityComponent.cpp · L1771 _{AbleCore · Private}
Compact context serialization	ablAbilityContext.cpp · L532 _{AbleCore · Private}
Replication conditions and push-model opt-in	ablAbilityComponent.cpp · L412 _{AbleCore · Private}
Shared per-visit random values	ablAbilityContext.cpp · L828 _{AbleCore · Private}

§12

Figures: 4
Source files: 8

Chapter 12

Connect the weapon to the move

EasyBallistics and bindable execution contexts.

Fire Barrel and Barrel Command put weapon control on the timeline. Bind settings, aim at shot time, and publish committed-shot gameplay results.

Fire Barrel exposes held-fire cleanup, barrel selection and bindable weapon configuration. — Refresh configuration while firing; choose how it restores or stops.

Look closer: barrel commands and shot-time aiming

Barrel Command lists firing, configuration, ammo, charge, chamber and spool operations. — **Commands:** fire, stop, configure, reload and more.

Easy Aim in View Trace mode exposes view-source and obstruction settings. — **Easy Aim:** choose the source and handle obstructions.

Select barrels explicitly or through targets; bind configuration and refresh/restore policy.
Command firing, ammo, charge, chamber unloading, fire mode, spooling and shooting blocking.
Aim through View Trace, a world point, actor or component; configure view source, offsets and obstructions. Dynamic binding and barrel delegates remain available.
Apply external stat overrides with 139 typed value getters. Result events expose committed authority-side shot data and captured bullet references.

Parts list · Source path key

What to find	File · line
Fire Barrel lifecycle and shot results	AblEBFireTask.cpp · L38 _{Ballistics bridge · Private/Tasks}
Barrel commands	AblEBCommandTask.cpp · L9 _{Ballistics bridge · Private/Tasks}
Barrel selection and configuration	AblEBTaskBase.cpp · L44 _{Ballistics bridge · Private/Tasks}
Shot-time Easy Aim resolution	EBEasyAim.cpp · L8 _{EasyBallistics · Private/Aiming}
Typed stat getters and overrides	EBStatLibrary.h · L8 _{EasyBallistics · Public/Stats}

Look closer: follow one execution's lifecycle

A bindable execution context supplies Bind Event to On Ability Timeline Changed and On Ability End. — Subscribe to the execution you started. Connect event handlers to react.

Bindable contexts expose Start, End, Interrupt, Branch and Timeline Changed delegates. Typed factories and conversion support ordinary and pooled contexts; end cleanup removes forwarding/listeners before reuse. The integration is optional and local.

Both bridges existed in the repository's earliest snapshot; their later evolution is part of this generation.

Parts list · Source path key

What to find	File · line
Context factories and conversion	AbleContextBindableBlueprintLibrary.cpp · L5 _{Bindable contexts · Private}
Delegate forwarding and disconnect	AbleContextBindableContext.cpp · L51 _{Bindable contexts · Private}
End cleanup before context reuse	AbleContextBindableContext.cpp · L120 _{Bindable contexts · Private}

§00

Figures: 2
Source files: 4

Chapter 00

The foundation underneath

Optional test tooling. Clearer plugin boundaries. No compatibility code left.

AbleTests groups editor automation, collision fixtures and reproducible measurements in a removable editor plugin. Production plugins do not depend on it.

Able Tests is an optional plugin for automation, collision benchmarks, fixtures and reports, shown disabled. — Available when needed; disabled in the captured editor session.

Look closer: modular plugins and upgrading

Plugin browser separates Able, Able Collision Engine, EasyBallistics, optional Able Tests and bindable contexts. — The framework, collision engine and bridges have distinct responsibilities.

Automation covers shape builds, query variants, batches, filters and lifecycle behavior. Reports record workloads, environment, seeds and latency distributions. The October review recorded 213 passing tests at that checkpoint. On 12 October the Able and Collision Engine product suite ran 73 tests, all passing, after the compatibility code was removed.

The project's own assets were converted once and saved in the current format; the conversions were then removed. Coming from the original Able, author these the current way:

Original Able	Generation 2.0
Ability-level playback	Timeline settings; Timeline 0 is the first phase.
Fixed collision volumes	Collision Shape with the matching ACE preset.
Arbitrary event payloads	Registered tag/type pairs and typed Send/Wait/Get nodes.
Key and action-name input	Input Actions, from the Context or picked by hand.
Animation checkboxes	Explicit playback, duration, speed and end policies.
Context named parameters	Ability State, or per-use dynamic bindings.
Get Cooldown / Get Max Stacks overrides	Cooldown and Max Stacks bindings.

Parts list · Source path key

What to find	File · line
Optional module and measurement command	AbleTestsModule.cpp · L13 _{AbleTests · Private}
Ability State coverage	AblAbilityStateTests.cpp · L83 _{AbleTests · Private/Tests}
Serialization and push-model coverage	AblNetworkContextTests.cpp · L68 _{AbleTests · Private/Tests}
Collision workloads and build measurements	AblShapePerformanceTests.cpp · L30 _{AbleTests · Private/Tests}

About these captures

Captured directly from shootcramental / Unreal Engine 5.8 on 11 October 2026. Cross Slash, Morning Star and registry entries are existing assets. The Collision Engine's handles, node Details, Shape-in-ability and profiler captures were added on 12 October 2026 by AbleTests' capture tools, which open existing assets without saving them; the profiler records a synthetic test workload.

AB_20_Showcase and ST_AbilityMemory are temporary, unsaved authoring examples. Graphs and inspectors demonstrate controls, not validated gameplay implementations. Existing asset classes and registry entries were read without editing them.

Images are tightly framed screen captures; UI values/results were not painted into them. The cover is an original vector. The 12 October captures came from a fresh editor build; no benchmark or network validation was run for this document.

Source path key

File labels use the module keys below. Append the displayed folder and filename to find the file locally; hovering a file link also shows its full repository path.

Module key	Repository folder
AbleCore	`plugins/AbleAbil334b52ee27f6V10/Source/AbleCore/`
AbleEditor	`plugins/AbleAbil334b52ee27f6V10/Source/AbleEditor/`
ACE	`plugins/AbleCollisionEngine/Source/AbleCollisionEngine/`
ACE Editor	`plugins/AbleCollisionEngine/Source/AbleCollisionEngineEditor/`
ACE Graph	`plugins/AbleCollisionEngine/Source/AbleCollisionEngineGraph/`
Ballistics bridge	`plugins/AbleEasyBallistics/Source/AbleEasyBallistics/`
EasyBallistics	`plugins/EasyBalle55a27bc8c3fV25/Source/EasyBallistics/`
Bindable contexts	`plugins/ableContextBindable/Source/AbleContextBindable/`
AbleTests	`plugins/AbleTests/Source/AbleTests/`

Code entry points were moved to the revision above, and checked against it, on 12 October 2026.

Markdown and the website share content and local images. This public repository contains only the showcase/media; plugin source and the Unreal project are maintained separately.

AbleGeneration 2.0

Contents