Quick Start

Goal: a player with a 20-slot backpack on their PlayerState, one item definition, a starting stack granted by the server, and a move request sent from the client through the routing component - in Blueprint and C++, with no other Crimson plugin required.

Show Plugin Content
Plugin content is hidden in the Content Browser by default. Click the settings cog in the Content Browser and tick Show Plugin Content so the plugin's classes appear in the parent-class pickers.

1. Enable the plugin and register item scan paths

Enable CrimsonInventory in Edit -> Plugins, then restart. The engine plugins it needs (Gameplay Abilities, Game Features, Modular Gameplay, SlateIM) are enabled with it. For a Blueprint project that is the whole installation; there is no .uproject or .Build.cs to hand-edit.

Then open Project Settings -> Crimson -> Crimson Inventory and add the folder that will hold your item Blueprints to Item Definition Scan Paths. Use the mount path the Content Browser's Copy Reference gives you for that folder. Item definitions are primary assets of type CrimsonInventoryItemDefinition; this list is how the asset manager finds them. An item outside a scanned path that nothing hard-references is cooked out of packaged builds.

Crimson Inventory project settings with one scan path added.
Verify
Restart the editor. Project Settings -> Crimson -> Crimson Inventory exists and lists your scan path.

2. Create a layout asset

A layout is a data asset that decides how entries are placed. Caps are not stored on it - they come from constraint tags you seed in step 3.

Content Browser -> right-click -> Miscellaneous -> Data Asset, pick CrimsonInventoryLayout_FlatSlot, name it DA_Layout_Backpack. Leave Max Slots Tag at its default Crimson.Inventory.Constraint.Slots.

Verify
Open DA_Layout_Backpack. Its Max Slots Tag shows Crimson.Inventory.Constraint.Slots.

3. Put the manager on your PlayerState

Player inventories belong on the PlayerState - it survives pawn death and respawn and is owned by exactly one connection. The owning actor must replicate.

Open (or create) your PlayerState Blueprint. Add Component -> Crimson Inventory Manager. In its Details panel set Layout Asset to DA_Layout_Backpack.

Then in the Event Graph: Event BeginPlay -> Has Authority (Branch, True) -> Initialize Inventory (target = the manager). For Default Int Constraints add one Make Crimson Tag Stack with Tag = Crimson.Inventory.Constraint.Slots, Stack Count = 20. Leave the other three inputs empty.

Set your GameMode's Player State Class to this Blueprint.

Verify
Play In Editor. Select the PlayerState in the World Outliner; the manager's Layout Asset is set and Tools -> Inventory Dev Tools -> Layout shows Crimson.Inventory.Constraint.Slots with max 20.

4. Create an item definition

Items are Blueprint classes, not data assets. Each one carries an ItemType tag and a list of instanced fragments.

In your scan-path folder: right-click -> Blueprint Class -> `CrimsonInventoryItemDefinition`, name it ID_HealthPotion. In Class Defaults set Display Name to Health Potion and Item Type to a tag of your choosing (create Item.Consumable in Project Settings -> Gameplay Tags first if you need one).

Under Fragments click + twice: add Inventory Data (tick Stackable, Max Stack Size = 20) and Item Visuals (assign an Item Icon texture).

Verify
Compile and save. Tools -> Inventory Dev Tools -> Items lists ID_HealthPotion in its item picker (the picker reads the scan paths from step 1).

5. Put the routing component on your PlayerController

The routing component is the only way a client talks to an inventory. It owns the Server_* RPCs, validates every request, and reports the outcome back to the requesting client.

Open your PlayerController Blueprint. Add Component -> Crimson Inventory Routing. Set the GameMode's Player Controller Class to this Blueprint. Nothing else to configure.

Verify
Play In Editor. Select the PlayerController in the World Outliner and confirm CrimsonInventoryRouting appears in its component list.

6. Give the player a starting stack (server)

In your GameMode Blueprint: Event OnPostLogin -> Get Player State -> Give Item To Actor (Context Actor = the PlayerState, Item Def = ID_HealthPotion, Stack Count = 5). The GameMode exists only on the server, so no authority branch is needed there.

Verify
Play In Editor. Tools -> Inventory Dev Tools -> Items shows one entry Health Potion x5 in slot 0 on the PlayerState's inventory.

7. Send a move request from the client

A client never calls MoveItemByEntry itself. It asks the routing component, which runs Server_MoveItem, validates the request, and reports the outcome back to the requesting client through the routing component's OnOperationResult event (channel Crimson.Inventory.Message.OperationResult).

In any widget or input event on the owning client: Find Routing Component (Context Actor = Get Owning Player) -> Move Item (Target = Find Inventory Manager on Get Owning Player -> Player State, Entry Id = the first element of Get Entry Views, T = Make Crimson Placement Target with Slot Index = 3).

Verify
Play with Net Mode = Play As Client, 2 players. Trigger the move on a client. Tools -> Inventory Dev Tools -> Items for that client's PlayerState shows the stack in slot 3, and the Messages tab shows an OperationResult with Operation = Move, bSuccess = true on the client that asked. The server's dev-tools view shows the same slot.
Have all the Crimson plugins?
CrimsonCore ships this whole loop prebuilt - backpack screen, drag and drop, context menu, tooltips - as a showcase (CrimsonCore - requires all Crimson plugins). Open CrimsonCore -> Inventory UI and skip straight to the verify steps above.
What's next
Learn the accessors once (How-To: Get the Building Blocks), then shape the inventory (How-To: Choose a Layout), restrict what it accepts (How-To: Add Constraints), wire the client-side API and its feedback message (How-To: Route UI Requests), and build chests, banks and per-player stashes (How-To: Build a World Container).