# Getting Started {% embed url="" %} Project Startup When you first open your project with GCC enabled, you will see the following message in your message log

Dont panic! This is not an error, this is a validation check from the `Game Features plugin` comes by default when you enabled the plugin and since GCC use this plugin for our `GameFeatureAction`. Upon clicking the link `Add entry to PrimaryAssetsTypesToScan?`, you should be prompt with a message to restart the editor.Once your editor is restarted,`DefaultGame.ini` file will be updated accordingly and those validation errors won't appear anymore. ## Prerequisites * Enable the Gameplay Ability System Plugin in the Edit -> Plugins window.

* To get the full range of capabilities of this system, add "GameplayAbilities", "GameplayTags", a2nd "GameplayTasks" to PublicDependencyModuleNames in your project's "(ProjectName).Build.cs" file. To use the Gameplay Ability System, add the three module names anywhere in the braced list, as follows: ``` PublicDependencyModuleNames.AddRange(new string[] { "GameplayAbilities", "GameplayTags", "GameplayTasks" }); ``` ## Setting with fresh project In this setup, we will be using the `Third Person BP template` for our initial project setup. Create that project by launching the Unreal Engine instance and choose Third Person Project with Blueprint as the project default.

Set your project location and name your project and create the project. ## AbilitySystemGlobals If you want to subclass classes like `UGameplayCueManager` or `FGameplayAbilityActorInfo`, you require to subclass `UAbilitySystemGlobals` to use those custom subclasses. By default, GCC use ASG to setup `FGCCGameplayAbilityActorInfo` and `FGCCAttributeSetInitter` You need to go to your project `Config->DefaultGame.ini under [/Script/GameplayAbilities.AbilitySystemGlobals]` `[/Script/GameplayAbilities.AbilitySystemGlobals]` \ `AbilitySystemGlobalsClassName=/Script/GCC.GCCAbilitySystemGlobals GlobalGameplayCueManagerClass=/Script/YourGame.YourGameplayCueManager PredictTargetGameplayEffects=false` \ `bUseDebugTargetFromHud=true ActivateFailIsDeadName=Ability.ActivateFail.IsDead ActivateFailCooldownName=Ability.ActivateFail.Cooldown ActivateFailCostName=Ability.ActivateFail.Cost ActivateFailTagsBlockedName=Ability.ActivateFail.TagsBlocked ActivateFailTagsMissingName=Ability.ActivateFail.TagsMissing ActivateFailNetworkingName=Ability.ActivateFail.Networking` ActivateFails config need to use what our native tag we define inside GCC GCCGameplayTags Used to define Global Activation Fail Tag Define in DefaultGame.ini ### AssetManager Setup \#Note In 5.3, the setup below is no longer necessary as the call `UAbilitySystemGlobals::Get().InitGlobalData()` is being call by default inside GameplayAbilityModule Go to `Tools->New c++ class` and find `UAssetManager` and create your assetmanager.

Open your IDE and add this code in your header and cpp file. Header: ``` public: static UMyAssetManager& Get(); /** Starts initial load, gets called from InitializeObjectReferences */ virtual void StartInitialLoading() override; ``` CPP: ``` #include "AbilitySystemGlobals.h" UMyAssetManager& UMyAssetManager::Get() { UMyAssetManager* Singleton = Cast(GEngine->AssetManager); if (Singleton) { return *Singleton; } else { UE_LOG(LogTemp, Fatal, TEXT("Invalid AssetManager in DefaultEngine.ini, must be MyAssetManager!")); return *NewObject(); // never calls this } } void UMyAssetManager::StartInitialLoading() { Super::StartInitialLoading(); UAbilitySystemGlobals::Get().InitGlobalData(); } ``` Starting in UE 4.24, it is now necessary to call `UAbilitySystemGlobals::Get().InitGlobalData()` to use TargetData, otherwise you will get errors related to `ScriptStructCache` and clients will be disconnected from the server. This function only needs to be called `once in a project`. Fortnite calls it from `UAssetManager::StartInitialLoading()` so thats why we do the same. * Next, go to your `Config/DefaultEngine.ini` and add this into your `[/Script/Engine.Engine]` ``` [/Script/Engine.Engine] AssetManagerClassName=/Script/MyProject.MyAssetManager ``` * Find the `ThirdPerson` folder and find your GameMode class. Reparent your game mode class to GCCModular` GameMode.h or `` `GCCModular` GameModeBase.h`` `

Now, we need to configure our Map to use `Your Game Mode`. Go into your World Settings Panel and select your GameMode in `GameMode Override`.

* Find the `ThirdPerson` folder and find your Character class. Reparent your character class to `GCCModularCharacter.h` * Right click, go to blueprint and create a `PlayerState class`. Reparent your player state class to `GCCModularPlayerState.h` * Right click, go to blueprint and create a `PlayerController class`. Reparent your player controller class to `GCCModularPlayerController.h` * Go to `Project Settings -> Maps and Modes -> Default Game Instance Class` and set `GCCGameInstance` or its child as the default game instance Once you finish, find the three dot near `Play` button, find `NetMode` and choose `Play As Client`.

Then, press Play. If we setup everything correctly, we should get no error. To confirm that, enter this command into the console command `showdebug abilitysystem` and you will be greeted with this debug panel.

## Initialization The PawnExtComponent extends the game frameworks init. A large part of the PawnExtComponent is boilerplate to kick that init off, for the most part you don't want to modify that. There are 4 major phases to this: 1\) Kick of the init framework. You'll see this done in a LOT of places and it is basically boilerplate. Ultimately this involves calling `CheckDefaultInitialization` on every component that needs to be part of this framework. Anywhere you see that called, consider to be boilerplate for the GameFrameworkInit. I should note: Although the PawnExtComponent "coordinates" a lot of this, all these steps really need to be on each of the components using the init. So you'll see CheckDefaultInitailization called and overriden in both the pawn ext comp and the hero comp. 2\) `CanChangeInitState`. This is where the component searches the actor to make sure enough data has been replicated to proceed to the next step of init. 3\) `HandleChangeInitState`. This is where the init is actually performed for components that are using the init framework. Generally this is just caching references to other components or to do any special init. 4\) Do the init on the components that haven't been added to the init framework.\ For the most part the PawnExtComp owns ASC init. This is because they didn't add those components to the init framework. The Hero Component is the place where in `HandleChangeInitState::CurrentState == GCCGameplayTags::InitState_DataAvailable && DesiredState == GCCGameplayTags::InitState_DataInitialized` initialize AbilitySystemComponent with PlayerState as its OwnerActor ``` if (UGCCPawnExtensionComponent* PawnExtComp = UGCCPawnExtensionComponent::FindPawnExtensionComponent(Pawn)) { // The player state holds the persistent data for this player (state that persists across deaths and multiple pawns). // The ability system component and attribute sets live on the player state. PawnExtComp->InitializeAbilitySystem(GCCPS->GetGCCAbilitySystemComponent(), GCCPS); } ``` Steps 2 and 3 are the "meat" of the init ### What is InitState? 1. Spawned is as it sounds 2. Data Available is where the ASC gets hooked up 3. Data Initialized is where all the init that relies on the ASC happens 4. Ready is an end state that doesn't do much. So the step order is 1\) (started by a bunch of stuff) 2\) Check if next init can happen. 3\) Do the next init, forward the init to step 4 (if relevant), then loop back to 1 for the next framework "state" (Spawned, Data Available, Data Init, Ready) (edited) If step 2 fails, then the actor collectively waits until step 1 is fired off again by one of the components hitting one of the many `CheckDefaultInitialization` conditions. ## AbilitySystemComponent As of GCC v2.6, GCC is configured to be use with ASC on the PlayerState as its OwnerActor. This is due to how GCCPawnExtensionComponent being setup to handle PlayerState as its OwnerActor to initialize AbilitySystemComponent. In the future, this will be change with the introduction of \`\`IGCCPawnAbilitySystemInterface\`\` to implement on AvatarActor to determine a way for the PawnExtComponent to generically determine what kind of pawn it is operating on. By default, AbilitySystemComponent live inside PlayerState and have a few properties you can configure. 1. Granting abilities by default (and if that ability have OnSpawn ActivationPolicy, it will activate) 2. Granting gameplay effects by default 3. Granting attribute set with its initialization value using data table 4. Granting ability sets by default ( As of GCC v2.6, this is not implemented yet) 5. Attribute Set Initialization Method where how attribute set will be initialize its values by using GameplayEffect, Ability Set or AttributeSetInitter ( As of GCC v2.6, this is not implemented yet)

### Attribute Set Initialization By default, AbilitySystemComponent provides a field called `Default Attributes` to initialize Gameplay Attributes through data table. You need to specify the attribute set you want use and specify the data table based on `AttributesMetaData` Inside your character blueprint, you can see a field under `GCC->Character->AttributeSets` and this is to add additional attribute set. In the future, this will be move to AbilitySystemComponent. Next, attribute set can be initialize using attribute set initter. Make sure to setup abilitysystemglobals inside your `DefaultGame.ini`. Next, you need to call UGCCAbilitySystemGlobals::GetASG().InitAttributeSetDefaults(GetterForYourASC(),InitializationKey, 1,true) when your ASC is initialize. In my case, i call it inside my PawnExtensionComponent after i call InitializeWithAbilitySystem

1. Import your .csv to be use for your values 2. Specify the path inside `[/Script/GameplayAbilities.AbilitySystemGlobals]` and under this `+GlobalAttributeSetDefaultsTableNames=/Game/PathToYourCSV/AttributeTable.AttributeTable` 3. Make sure your attribute is `YourAttributeSet.YourAttribute` inside your table or the initter cant find the attribute and initialize the value

Open up the gameplay debugger for GAS with `showdebug abilitysystem`, we should see values for each Gameplay Attribute we configured in the Data Table updated accordingly.\
## InputBinding with Enhanced Input System From Unreal Engine 5.1 onwards, the EnhancedInput plugin will replace the legacy input system. If your project is from Unreal Engine 5.0 and below, make sure to enable the EnhancedInput Plugin by: `Plugins->Input->EnhancedInput` By default, the `Third Person template` preconfigured to use EnhancedInputSystem and there's some setup configured.

We can just use the preconfigured Binding system on `BeginPlay` or using `GCCAbilityInputBinding` component.In this setup, we want to use the component as it comes with some convenience functions for input binding. \ Navigate to`Engine > Input` category inside you `Project Settings`. * `EnhancedPlayerInputComponent` for the `Default Input Component Class` to `GCCInputComponent`

Click the `Add` button in the components panel, and add `GCCAbilityInputBinding` to your Character

In the details panel, you can configure you `Input Mapping Context` and `Input Priority`

We can delete the `BeginPlay` setup and use the component to bind our input mapping context. The `Third Person template` also comes with preconfigured `InputActions` and `InputMappingContext` in `ThirdPerson/Input` folder. To see if you configure Enhanced Input correctly, go to the command bar and use the following command: `showdebug enhancedinput`