Quick Start

Goal: a pawn with a working Ability System Component, one attribute, and one ability you can press a key to activate - built from nothing, with no other Crimson plugin required beyond CrimsonCommon.

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 you can see and subclass the plugin's types.

1. Enable the plugin and register the globals class

Enable CrimsonAbilitySystem (and CrimsonCommon, and Epic's GameplayAbilities) in Edit -> Plugins, then restart.

Then add this to Config/DefaultGame.ini. This is not optional - the plugin's effect context carries the data every other feature reads, and GAS only creates it if the globals class is registered.

ini
[/Script/GameplayAbilities.AbilitySystemGlobals]
AbilitySystemGlobalsClassName=/Script/CrimsonAbilitySystem.CrimsonAbilitySystemGlobals
The Plugins window with CrimsonAbilitySystem enabled.
Verify
Restart the editor. Open Project Settings -> Crimson -> Crimson Ability System and confirm the section exists.

2. Create an attribute set

GAS needs at least one attribute set before an ability can cost anything. UCrimsonAttributeSet is the base; you declare the actual attributes. This step is C++ only - FGameplayAttributeData members and their accessors cannot be declared in Blueprint.

cpp
// MyCombatSet.h
#pragma once


#include "CoreMinimal.h"
#include "AbilitySystemComponent.h"        // ATTRIBUTE_ACCESSORS
#include "Attributes/CrimsonAttributeSet.h"
#include "MyCombatSet.generated.h"


UCLASS()
class MYGAME_API UMyCombatSet : public UCrimsonAttributeSet
{
    GENERATED_BODY()


public:
    UPROPERTY(BlueprintReadOnly, ReplicatedUsing = OnRep_Stamina, Category = "Combat")
    FGameplayAttributeData Stamina;
    ATTRIBUTE_ACCESSORS(UMyCombatSet, Stamina);


    virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& Out) const override;


protected:
    UFUNCTION()
    void OnRep_Stamina(const FGameplayAttributeData& Old) { GAMEPLAYATTRIBUTE_REPNOTIFY(UMyCombatSet, Stamina, Old); }
};
cpp
// MyCombatSet.cpp
#include "MyCombatSet.h"
#include "Net/UnrealNetwork.h"


void UMyCombatSet::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& Out) const
{
    Super::GetLifetimeReplicatedProps(Out);
    DOREPLIFETIME_CONDITION_NOTIFY(UMyCombatSet, Stamina, COND_None, REPNOTIFY_Always);
}
Attributes are C++ only
This is a GAS constraint, not a plugin one. Blueprint cannot declare FGameplayAttributeData. Everything AFTER this step is available in both Blueprint and C++.
Verify
Compile. In any Blueprint, drop a Get Float Attribute node and confirm Stamina appears in the attribute dropdown.

3. Put an ASC on your PlayerState

The convention this plugin is built around is PlayerState owns the ASC - it survives pawn death and respawn. You have two ways in.

Reparent your PlayerState Blueprint to ACrimsonAbilityPlayerState: open it, File -> Reparent Blueprint, choose CrimsonAbilityPlayerState. It already creates the ASC and the granted-handles bookkeeping.

Then in Class Defaults, set your GameMode's Player State Class to this Blueprint.

Where the base class comes from
ACrimsonAbilityPlayerState derives from ACrimsonModularPlayerState (CrimsonCommon). Both plugins must be enabled.
Verify
Play In Editor. Select your PlayerState in the World Outliner and confirm a CrimsonAbilitySystemComponent is present in the Details panel.

4. Create an ability and an ability set

Create the ability first, then the set that grants it.

Content Browser -> right-click -> Blueprint Class -> `CrimsonGameplayAbility`. Name it GA_Test. Open it and in Class Defaults set Activation Policy to OnInputTriggered. In the graph, override Event ActivateAbility and wire it to a Print String, then End Ability.

Now the set: right-click -> Miscellaneous -> Data Asset, pick CrimsonAbilitySet, name it AS_Test. Add one entry to Granted Gameplay Abilities, set Ability to GA_Test, and set Input Tag to a tag you create called InputTag.Test.

Ability sets live in CrimsonCommon
UCrimsonAbilitySet is a CrimsonCommon type. It is the standard way to grant a batch of abilities, effects and attribute sets together.
Verify
The GA_Test asset compiles and AS_Test lists it under Granted Gameplay Abilities.

5. Grant the set and activate by input tag

Granting is server-authoritative. Input arrives on the owning client and is forwarded to the ASC by tag.

In your PlayerState Blueprint: Event BeginPlay -> Switch Has Authority (Authority) -> Give To Ability System (from AS_Test), passing the ASC from Get Crimson Ability System Component.

In your PlayerController or Character, bind an Enhanced Input action and call Ability Input Tag Pressed on the ASC with InputTag.Test. Wire the action's Completed pin to Ability Input Tag Released with the same tag.

Bind both Pressed and Released
Activation policies and the toggle/charge subclasses rely on the release edge. Binding only the press makes held abilities never finish.
Verify
Play In Editor and press the key - your Print String fires.

Now set Net Mode to Play As Client with 2 players and press the key on the client. It must still fire: the client predicts the activation and the server confirms it. If it only works in standalone, the ability was granted on the client instead of the server.

Next steps

  • How-To: Get the Building Blocks - how to reach the ASC, settings and subsystems from anywhere.
  • How-To: Grant an Ability Set - the real granting path, with attribute sets and effects.
  • Concept: Gameplay Ability - activation policies, activation groups and what they solve.