reznok/gmcabilitysystem/gmas-setup

Behavior below was verified against GMC 2.3.x and GMAS 1.4. Confirm signatures in this project's own headers (paths are relative to each plugin's root, e.g. Source/GMCCore/Public/Components/GMCReplicationComponent.h); GMC's source is not part of this plugin.

This skill gets GMAS (GMC Ability System) into a project and a first pawn wired to it, in C++ or Blueprint. The rules that govern what you build afterwards live in gmas:gmas-rules (where state lives, binding order, effects, server operations) and gmas:gmc-prediction (GMC's move cycle). GMAS paths below are relative to Source/GMCAbilitySystem/; GMC paths to the GMC plugin root.

Requirements

GMAS has two modules, GMCAbilitySystem (runtime) and GMCAbilitySystemEditor (editor), plus from 1.4.1 GMCAbilitySystemTests (UncookedOnly: the specs and test stubs, never in a cooked or Shipping game); all load at the Default phase.

Installing GMAS

Submodule (recommended: upgrades are a pointer bump, and you can read the exact tree you build against):

git submodule add -b main https://github.com/reznok/GMCAbilitySystem.git Plugins/GMCAbilitySystem
git submodule update --init --recursive

• -b main follows releases (tags v1.x.y); -b dev follows the integration branch, which the repository's docs/BRANCHING.md recipe uses and which moves daily. To pin a release: git -C Plugins/GMCAbilitySystem checkout v1.4.0, then commit the pointer. To update: git submodule update --remote Plugins/GMCAbilitySystem, rebuild, commit the pointer (gmas:gmas-upgrade).
• Never patch inside the submodule: fix upstream, then bump the pointer. The plugin's name is GMCAbilitySystem whatever the folder is called.

Copied folder: download a release archive (or git clone --depth 1 -b v1.4.0) into Plugins/GMCAbilitySystem and drop its .git. You own updates from then on: diff against the release you copied when upgrading.

`.uproject`:

"Plugins": [
    { "Name": "GMC", "Enabled": true },
    { "Name": "GMCAbilitySystem", "Enabled": true }
]

`Build.cs` of every module that includes GMC or GMAS headers:

PublicDependencyModuleNames.AddRange(new string[] {
    "Core", "CoreUObject", "Engine", "InputCore", "EnhancedInput", "GameplayTags",
    "GMCCore", "GMCAbilitySystem"
});

GMCAbilitySystem exports GMCCore, GameplayTags, GameplayTasks, EnhancedInput, StructUtils and NetCore as public dependencies (Source/GMCAbilitySystem/GMCAbilitySystem.Build.cs), so its headers compile in your module without more. List GMCCore and GameplayTags anyway: your own headers use them directly. List GameplayTasks yourself when you subclass the ability system component (a UGameplayTasksComponent) or write ability tasks. StructUtils is normally not needed on any version: on 5.5+ FInstancedStruct lives in CoreUObject (header StructUtils/InstancedStruct.h), and on 5.4 UBT propagates the module through GMAS's public dependencies; add it only if your 5.4 build complains.

Regenerate project files, build (a source plugin compiles with the project), open the editor: Edit → Plugins lists "GMAS - GMC Ability System" under the GMAS category.

C++ wiring

Timing. AGMC_Pawn::PostInitializeComponents runs the bind, so your BindReplicationData_Implementation executes before any BeginPlay. The ASC reads AttributeDataAssets during the bind (InstantiateAttributes) and StartingAbilities, AbilityMaps, StartingTags in its own BeginPlay; StartingEffects go out from the server once the pawn has a controller. Fill all of them in class defaults, the constructor, or in the pawn's PostInitializeComponents before Super, identically on every machine (gmas:gmas-rules).

UGMC_OrganicMovementCmp implements four of the five itself (all but the ancillary tick), so always call Super first. Where the ASC call sits relative to your own logic inside a hook is yours to decide; keep it the same on every machine.

// MyMovementCmp.h
#pragma once
#include "Components/GMCOrganicMovementComponent.h"
#include "Components/GMCAbilityComponent.h"
#include "MyMovementCmp.generated.h"
 
UCLASS()
class UMyMovementCmp : public UGMC_OrganicMovementCmp
{
    GENERATED_BODY()
public:
    virtual void BindReplicationData_Implementation() override;
    virtual void PreLocalMoveExecution_Implementation(const FGMC_Move& LocalMove) override;
    virtual void GenPredictionTick_Implementation(float DeltaTime) override;
    virtual void GenSimulationTick_Implementation(float DeltaTime) override;
    virtual void GenAncillaryTick_Implementation(float DeltaTime, bool bLocalMove, bool bCombinedClientMove) override;
protected:
    UPROPERTY(Transient) TObjectPtr<UGMC_AbilitySystemComponent> AbilitySystem;
};
 
// MyMovementCmp.cpp
void UMyMovementCmp::BindReplicationData_Implementation()
{
    Super::BindReplicationData_Implementation();
    // Your own Bind* calls go here (gmas:gmc-prediction).
    AbilitySystem = GetOwner()->FindComponentByClass<UGMC_AbilitySystemComponent>();
    check(AbilitySystem);
    AbilitySystem->GMCMovementComponent = this;   // explicit; 1.4.1+ would find it, 1.4.0 crashes without it
    AbilitySystem->BindReplicationData();          // the ASC binds last
}
void UMyMovementCmp::PreLocalMoveExecution_Implementation(const FGMC_Move& LocalMove)
{
    Super::PreLocalMoveExecution_Implementation(LocalMove);
    AbilitySystem->PreLocalMoveExecution();
}
void UMyMovementCmp::GenPredictionTick_Implementation(float DeltaTime)
{
    Super::GenPredictionTick_Implementation(DeltaTime);
    // Predicted game logic that abilities depend on goes here (bound tags via MatchTagToBool).
    AbilitySystem->GenPredictionTick(DeltaTime);
}
void UMyMovementCmp::GenSimulationTick_Implementation(float DeltaTime)
{
    Super::GenSimulationTick_Implementation(DeltaTime);
    AbilitySystem->GenSimulationTick(DeltaTime);
}
void UMyMovementCmp::GenAncillaryTick_Implementation(float DeltaTime, bool bLocalMove, bool bCombinedClientMove)
{
    Super::GenAncillaryTick_Implementation(DeltaTime, bLocalMove, bCombinedClientMove);
    AbilitySystem->GenAncillaryTick(DeltaTime, bCombinedClientMove);
}

The pawn adds the movement component (and, from a bare AGMC_Pawn, a root collision component plus CreateDefaultSubobject<UGMC_AbilitySystemComponent>); the pawn's root becomes GMC's updated component. Attribute data chosen at runtime (an archetype) is injected before the bind:

// MyPawn.h  (includes: Actors/GMAS_Pawn.h, MyMovementCmp.h, Attributes/GMCAttributesData.h, InputAction.h;
//            the .cpp adds EnhancedInputComponent.h)
UCLASS()
class AMyPawn : public AGMAS_Pawn
{
    GENERATED_BODY()
public:
    AMyPawn(const FObjectInitializer& Init);
    virtual void PostInitializeComponents() override;
    virtual void SetupPlayerInputComponent(UInputComponent* PlayerInputComponent) override;
protected:
    void OnDash(const FInputActionInstance& Instance);
    UPROPERTY(VisibleAnywhere)  TObjectPtr<UMyMovementCmp> Movement;
    UPROPERTY(EditDefaultsOnly) TObjectPtr<UGMCAttributesData> Attributes;
    UPROPERTY(EditDefaultsOnly) TObjectPtr<UInputAction> DashAction;
};
 
// MyPawn.cpp
AMyPawn::AMyPawn(const FObjectInitializer& Init) : Super(Init)
{
    Movement = CreateDefaultSubobject<UMyMovementCmp>(TEXT("Movement"));
}
void AMyPawn::PostInitializeComponents()
{
    if (Attributes) { AbilitySystemComponent->AttributeDataAssets.AddUnique(Attributes); } // same asset everywhere
    Super::PostInitializeComponents();                                                       // GMC binds in here
}

Blueprint wiring

The same five events, in the movement component Blueprint (a child of GMC_OrganicMovementCmp), with the ASC on the character. Step by step with screenshots: https://github.com/reznok/GMCAbilitySystem/wiki/Getting-Started (the wiki is stale: since 1.0 the tag-to-class rows live in GMCAbilityMapData assets, below, not in an editable map, and its Ability.Jump map key and activation tag are an Input.* tag today).