Everything below is callable from Blueprint with no C++. Nodes are grouped by intent rather than by
class, because that is how you look for them.
Authority-only nodes are marked ⬤ server. They return false and do nothing on a client — use the
Request variant instead. Since 1.0.0 they also say so: a ⬤ server node called on a client logs a
warning naming itself and the Request form, because from inside a graph a refusal is otherwise
indistinguishable from an unwired node.
Running an inventory needs no C++. Inventing a new kind of fragment, rule, layout or transaction
does, because those are USTRUCTs and a Blueprint struct cannot inherit from a native one. The
shipped set is large and composable, so most projects never reach that edge — see
Extending → What needs C++ for the exact line.
Finding an inventory
| Node | Returns |
|---|
| Get Inventory Manager (Actor) | The actor's inventory, via IEDInventoryOwner or its components |
| Get Container (Tag) | The first container of a kind |
| Get Containers By Tag (Tag) | All containers of a kind |
| Get Container By Id (Guid) | Exactly one container |
| Get Containers By Item (Handle) | The containers an item brought with it |
| Get Owning Item (Container) | The item a container came with; invalid for one the inventory owns |
| Get Containers | Every container |
| Get Container Definition (Tag) | The asset a container was built from |
| Get Default Container | The container the default query selects |
Adding and removing — whole inventory
| Node | Notes |
|---|
| Try Add Item (Definition, Count, Preferred Container) ⬤ server | Routed by data when no container is named |
| Try Remove Items (Definition, Count) ⬤ server | Spans containers, smallest piles first, all-or-nothing |
| Try Remove Item (Handle) ⬤ server | One specific stack |
| Try Move To Container (Handle, Target Tag, Count) ⬤ server | Between this actor's own containers |
| Get Item Count (Definition) | Summed across everything |
| Has Item (Definition, Count) | |
| Find Container For (Definition, Count) | Where it would go; null means nowhere |
Adding and removing — one container
Call these on a UEDContainer, not on a component.
| Node | Notes |
|---|
| Try Add Item (Definition, Count) ⬤ server | Stack-aware |
| Try Remove Item (Handle) ⬤ server | |
| Try Remove Items (Definition, Count) ⬤ server | |
| Try Transfer Item (Handle, Target, Count) ⬤ server | −1 transfers the whole entry |
| Try Add Existing Item (Entry) ⬤ server | Puts an item BACK with its history — use for pickups and loads |
| Request Transfer Item (Handle, Target, Count) | Safe anywhere |
| Request Sort (Mode) | Safe anywhere |
| Request Transaction (Transaction) | Safe anywhere |
| Evaluate Add Item (Definition, Count) | Dry run + player-readable reason |
Acting on one container
Every player-facing operation is a Request: safe to call from anywhere, routed to the server, and
it builds the transaction for you so you never assemble an Instanced Struct to do something ordinary.
| Request (anywhere) | Does |
|---|
| Request Move | Moves an entry; pass this container as the target to reposition within it |
| Request Split | Splits N units into a new stack |
| Request Merge | Pours one stack into another |
| Request Swap | Exchanges two entries; null other container swaps inside this one |
| Request Destroy | Throws an item away for good |
| Request Transfer Item | Stack-aware move into another container |
| Request Sort | Consolidates partial stacks, then re-packs |
Server code that wants the result immediately keeps Try Add Item, Try Remove Item,
Try Remove Items and Try Transfer Item. The other operations used to have a Try twin as
well; nothing called them, and what they offered was a way around the routing that exists for a
reason. Build the transaction and run it if you need one.
Reading a container
| Node | Returns |
|---|
| Get All Items | Every entry, in storage order |
| Find Item By Handle (Handle) | An entry; false when absent |
| Contains Handle / Contains Definition | Boolean |
| Count By Definition (Id) | Units in this container |
| Get Total Item Count | Units of everything |
| Find Handles By Definition (Id) | Every matching handle |
| Get Container Type / Get Container Id | Identity |
| Get Max Slots / Is Unlimited | Capacity |
| Get Owning Actor / Has Authority | |
| Get Acceptance Error / Can Accept Entry (Entry, Instigator) | Would this be accepted |
| Has Rule Of Type (Struct) | |
Containers at runtime
| Node | Notes |
|---|
| Add Container (Definition) ⬤ server | Returns the live container |
| Add Nested Container (Definition, Owning Item) ⬤ server | Belongs to an item |
| Remove Container (Container) ⬤ server | Refuses one an item owns |
| Remove Container By Tag (Tag) ⬤ server | The first of a kind |
| Try Handle Stranded Item (Container, Handle) ⬤ server | Runs the handler chain |
Items and fragments
| Node | Returns |
|---|
| Resolve Definition (Id) | The definition asset |
| Resolve Item Definition (Entry) | The same, from an entry |
| Get Item Display Name (Entry) | Falls back to the asset name |
| Get Item Footprint (Entry) | Cells covered, rotation included |
| Does Item Cover Cell (Entry, Cell) | |
| Get Fragment (Definition, wildcard) | Copies a fragment by output pin type |
| Has Fragment Of Type (Definition, Struct) | |
| Evaluate Prerequisites (…) | Boolean + player-readable reason |
| Is Valid (Item Entry) · Is Promoted · Get Instance · To String | Entry basics |
| Get Transaction Error Text (Error) | A sentence a player can read, for every failure reason |
| Preload All Item Definitions (Callback) | Call during load. Without it definitions resolve to null and stacking, weight, display and grants silently degrade. Safe to call from several places at once — calls made while a preload is running join it instead of starting another, and every callback still fires |
Events
| Event | Fires |
|---|
| On Inventory Changed | Any change in any container |
| On Stack Count Changed | An item's actor-wide total changed |
| On Containers Changed | A container appeared or went away |
| On Initialization Finished | Setup finished or gave up |
| On Session Opened / Closed | A world container was opened or closed |
| On Transaction Result | The outcome of a Request* |
| On Weight Changed | Weight module |
| On Item Used | Usable subsystem |
When Ready (Callback) runs a callback once the inventory is usable, immediately if it already is.
Reacting to what an actor carries
On a Blueprint deriving from UEDContainerObserverComponent — see
Extending → An observer component.
| Node | Does |
|---|
| Can Observe (override) | Say whether your prerequisites are met at all |
| Reevaluate Item (override) | React to one item |
| Get Tracked Handles (override) | Name the items you hold state for |
| Stop Tracking Item (override) | Undo one item |
| Refresh Bindings | Bind any container that is not bound yet |
| Refresh All Items | Re-evaluate everything held and everything tracked |
| Notify Observation Context Changed | Tell it a Can Observe prerequisite changed — call this from On Possessed Pawn Changed for an observer that lives on a Controller and applies things to a Pawn |
| Filter Accepts Tag / Filter Accepts Tags | The shared "an empty query accepts everything" rule |
Item attributes
Tag-keyed numbers carried by one item — ammo, charges, durability, rolled stats. They live on the
entry, so a stack of two hundred arrows carries them without anything being instanced, and they
replicate and save with the item. Two stacks only merge when every attribute matches, so a rifle with
29 rounds never fuses with one that has 12.
Reading works on any machine. Writing is server-authoritative and goes through a transaction.
| Node | Notes |
|---|
| Get Item Attribute (Entry, Tag) | 0 when absent — 0 and absent are the same thing |
| Get All Item Attributes (Entry) | Every (tag, value) pair — for tooltips that list whatever is there |
| Get Attribute By Handle (Container, Handle, Tag) | When you hold an id rather than a copy |
| Find Attribute In Inventory (Inventory, Handle, Tag) | Searches every container |
| Set Item Attribute (Container, Handle, Tag, Value) ⬤ server | Absolute. 0 removes it |
| Add Item Attribute (Container, Handle, Tag, Delta) ⬤ server | Applied against the value when the server runs it — the one to use for spending |
| Set / Add Attribute In Inventory ⬤ server | Finds the holding container for you |
Three operations at three scopes, and that is the whole set. There is no Has node (Get above zero
is the same question), no Num node (the listing has a Length), no Remove node (Set to 0), and no
second family of nodes taking the state struct instead of the entry it lives on.
Values are non-negative int32. For a fraction, store it scaled (0.85 as 85); for structured or
signed state, use a UEDItemInstance subclass.
Open containers
| Node | Notes |
|---|
| Open Session (Container) ⬤ server | Grants this actor access to a container it does not own. Ignored on a client — see Transactions |
| Close Session (Container) | Safe from a client; giving up access needs no permission |
| Close All Sessions | |
| Has Open Session (Container) | What this machine believes |
| Has Open Session Authoritative (Container) | What the server knows; false off the authority |
| Get Open Sessions | |
| Validate Sessions ⬤ server | Closes sessions out of range. Only does anything when Max Session Distance is set |
User interface
| Node | Notes |
|---|
| Set Source Inventory (Inventory, Container Tag) | Prefer this. Binds by role; survives replication timing |
| Set Source (Container) | Only for a container you already hold |
| Get View Model / Set View Model | |
| Get Container (view model) | |
| Find Entry (Handle) / Get Num Entries | One entry, or how many. Get Entries is C++ only: a pure node returning the whole array copies it at every pin that reads it |
| On Entry Changed (Handle, Change Type) | One entry changed — refresh one slot |
| On Reset | The contents are not comparable: rebuild |
| Request Move / Transfer / Swap / Split / Sort | Server-authoritative |
| Cycle Sort Mode | Advances and re-sorts; returns the new mode |
| Get Sort Mode Label (Mode) | Button caption |
| Set Quick Transfer Counterpart (View) | The double-click partner |
| Set Selected Index / Get Selected Index | Bar views |
| Get Entry At Index (Index) | Bar views |
Feature modules
| Node | Module |
|---|
| Can Craft (Container, Recipe) · Request Craft | Crafting |
| Match Grid · Find Grid Recipe · Request Craft From Grid · Get Grid Size | Crafting — shaped |
| Is Burning · Get Cook Fraction · Get Burn Fraction · Get Burn Remaining · Get Fuel Seconds · On Burn Changed · On Produced | Crafting — processing |
| Request Buy / Request Sell · Get Buy Price / Get Sell Price | Trading |
| Roll Loot Table (Table, Budget) · Give Loot (Container, Loot) ⬤ server | Loot |
| Is Usable · Get Use Info · Request Use Item | Usable |
| Get Item Weight · Get Container Weight · Get Container And Nested Weight · Get Inventory Weight · Get Weight In Scope | Weight |
| Is Encumbered · Get Over Encumbrance · Get Weight Fraction · On Encumbrance Changed | Weight |
| Get Durability · Get Max Durability · Apply Wear · Repair | Durability |
| Request Equip / Try Equip ⬤ server · Request Unequip / Try Unequip ⬤ server | Equipment |
| Find Equipment Container · Is Item Equipped | Equipment |
| Make Equipment Layout (Slot Tags) · Get Equip Slot · Is Equippable | Equipment |
Show Item · Show Definition · Clear Model (UEDWorldModelComponent) | World |
| Rotate item transaction · Get Item Footprint · Does Item Cover Cell | Spatial |
| Make Grid Layout (Width, Height) · Make List Layout (Slot Count) | Layout — build a container's shape |
| Slot: Auto · Slot: At Index (Index) · Slot: At Cell (Cell, Rotation) · Slot: At Tag (Slot Tag) | Layout — say where an item goes |
Where next