Quick Start

By the end of this page you'll have a skill tree asset, a manager that owns its runtime state on the Player State, and a node you can activate from code - replicated to clients.

Prerequisites
CrimsonCommon and CrimsonSkillTree are installed. Your Player State already has (or will get) a Gameplay Ability System Component if you want GAS-driven conditions/events.

1. Enable the plugin

Open Edit -> Plugins, type Crimson in the search box, tick CrimsonSkillTree's checkbox (and CrimsonCommon, its dependency), and restart the editor when prompted. For a Blueprint project that's the entire install - you never hand-edit the .uproject or any .Build.cs.

Edit -> Plugins -> search 'Crimson' -> tick CrimsonSkillTree's Enabled checkbox -> restart the editor.
Blueprint-only project?
Enabling the plugin in Edit -> Plugins is the whole installation - there is no .uproject or .Build.cs to edit. The editor writes the plugin entry for you. The C++ step below is needed only when you reference CrimsonSkillTree types from your own C++ code.

C++ projects: after enabling the plugin above, add its module to your build file so your game code can use its types:

csharp
// YourGame.Build.cs
PublicDependencyModuleNames.Add("CrimsonSkillTree");
Verify
The plugin shows as enabled in the Plugins window and the editor restarts without errors.

2. Add the manager and implement the host interface

UCrimsonSkillTreeManager holds the runtime state. Put it on the Player State so it replicates with the player and survives pawn respawns.

Player State Blueprint -> Add Component -> Crimson Skill Tree Manager.

Now make the host actor itself implement `ICrimsonSkillTreeInterface`. The manager calls this interface on the actor that owns it to resolve the logical owner of the tree's effects (usually the controlled Pawn). Implement all three methods.

Screenshot pendingImages/CrimsonSkillTree/qs-implement-interface.png
Player State Blueprint -> Class Settings -> Interfaces -> Add -> Crimson Skill Tree Interface, then override Get Skill Tree Owner / Owner Character / Manager Component.
Without the interface the manager fails silently
The manager resolves its owner with ICrimsonSkillTreeInterface::Execute_GetSkillTreeOwner(GetOwner()) - a call on the host actor. If the host doesn't implement the interface, initialization aborts: in editor / development builds the call trips a check() and crashes; in shipping / test builds the check is compiled out and the manager never initializes - no trees, no nodes, and no error logged. This step is not optional.
Verify
The host actor lists Crimson Skill Tree Interface under Class Settings -> Implemented Interfaces (Blueprint) or derives from ICrimsonSkillTreeInterface (C++). On Play the manager initializes and OnSkillTreeStateUpdated can broadcast.

3. Create a skill tree asset

Content Browser -> right-click -> Crimson -> Skill Tree Asset. Double-click to open the two-graph editor. In Logic mode, right-click -> Add Skill, wire it from the Root node's Out pin. Switch to Visual mode to see the auto-spawned mirror and lay it out.

Content Browser -> Crimson -> Skill Tree Asset, then add a Skill in Logic mode and wire it from Root.
Verify
The Visual graph shows a mirror node for your new Skill, and Compile reports nodes with no validation errors.

4. Configure the trees

The manager initializes itself - in BeginPlay it binds to the owning pawn/controller and builds the runtime tree instances once they're ready, so there is no init function to call. Your one job is to fill `Configured Skill Trees` with the tree assets it should own (each entry pairs a type tag with a UCrimsonSkillTree). GAS-driven conditions and events resolve the owner's Ability System Component automatically.

Manager component -> Details -> Configured Skill Trees: add an entry (type tag + tree asset). Initialization is automatic.
Add trees at runtime too
Beyond the configured list, you can inject trees on the fly with AddDynamicSkillTree (e.g. from equipment or a Game Feature) and remove them with RemoveDynamicSkillTree.
Verify
Hit Play. The manager creates its tree instances without warnings, and OnSkillTreeStateUpdated broadcasts when node state changes.

5. Activate a node at runtime

Client code calls the manager; the manager fires a server RPC and validates authoritatively. Read the target NodeGuid from the asset or a UI widget.

Call Request Skill Node Action (Node Guid, Activate) on the manager.
Verify
In a Listen Server + Client PIE test, the node's state changes to Set on both, and OnSkillTreeStateUpdated broadcasts so your UI can refresh.
What's next
Lay out and style the tree (How-To: Author a Skill Tree, How-To: Style Connections), drive batches/respec/loadouts (How-To: Drive Node Actions), persist it (How-To: Save & Load), and show it (How-To: Display the Skill Tree).