#fanta update

I’ve started building FANTa on Unreal, doing some basic setup. We’ll be building on the foundation we lay here in the coming weeks and months. I’m still looking for a repository big enough to handle the FANTa file sizes. I’ll think of something. I’m also trying to strike a careful balance between doing specific things and being more general for speed and brevity’s sake. If you want to follow along in the meantime, here are the steps to get to where I currently am.

EDIT: Forgot to mention - you’ll need a C++ editor and compiler for this. I suggest Microsoft Visual Studio 2019 Community Edition. [Get it from Microsoft for free]. If you really don’t like Visual Studio, there’s some additional information on [setting up a different IDE here]. Remember, you can always compile your C++ code by hitting the Compile button in the editor.

We’ll start by creating a new Unreal 4.24.2 project. Under Games, choose the Third Person template, then select C++ instead of Blueprint. We’ll still be doing most of the work in blueprints, but we need C++ in order to work in the Gameplay Ability System that we’ll be using for the traversal mechanics and such, like so:

(I’ve already created a FANTa project, which is why it says it already exists)

Optionally, you can then go to the Unreal Marketplace and add a Paragon character to your FANTa project. The AAGD Patreon Dev Team voted in Terra for our player character model, so that’s who I am using.

After you’ve gotten the project created, you need to set up the basic Gameplay Ability System in C++. [Click here for the instructions to do so]. Make sure you have the Gameplay Abilities Plugin enabled, and make the core changes to FANTaCharacter.cpp and .h. You really only need to make the changes up until the Binding to Character Input section.  Find the ThirdPersonCharacter Blueprint and you should see the AbilitySystem inherited after making and compiling the C++ changes. Like this:

We’ll rename ThirdPersonCharacter to PlayerCharacter, since that’s probably a more accurate name for it.

For fun, we can also change the blueprint’s Skeletal Mesh to Terra (or whoever you decided to choose) and the Animation Blueprint to Terra_AnimBlueprint (use the dropdown menu to choose) and it should swap the mannequin for our big beefy axe lady. Compile and save everything.

Now we need a Gameplay Ability to give to the player character. Let’s start by creating a Blueprint which inherits from Gameplay Ability like so:

Name the GameplayAbility blueprint something like DebugTestAbility and open it up. We just want something for us to make sure it is being activated properly. Event ActivateAbility should just call PrintString with some message to indicate that the ability has been activated, like this:

Next, we need to add a little bit more code. We want to add a way to grant abilities to a FANTa Character and we want it callable via Blueprints, so I wrote this bit in FANTaCharacter.h under public:

UFUNCTION(BlueprintCallable, Category = "Abilities") void GiveAbility(TSubclassOf<class UGameplayAbility> AbilityToGive);

This declares a new class function called GiveAbility that is callable by blueprint that takes a Gameplay Ability subclass as a parameter. Then, in FANTaCharacter.cpp, we define the function as so:

void AFANTaCharacter::GiveAbility(TSubclassOf<class UGameplayAbility> AbilityToGive) {    if (AbilityToGive)    {    AbilitySystem->GiveAbility(FGameplayAbilitySpec(AbilityToGive.GetDefaultObject(), 1, 0));   } }

This means that we can call GiveAbility from any blueprint that inherits from FANTaCharacter with a class definition for an ability and it will give that ability to that FANTaCharacter. Build it and it should be good.

Now, we need some way to make sure that this ability has a tag so we can activate it by that tag. In the Details of DebugTestAbility, edit the Ability Tag and add a new tag Debug.Test.DebugTestAbility to identify this ability in specific.

This should be enough to set up our debug test ability.

Now we have to give this ability to the player character. Go back to the PlayerCharacter blueprint and create a new variable called StartingAbility. The variable type will be Gameplay Ability Class (not object). Then, in Event BeginPlay on PlayerCharacter, give that ability to the player character like so:

You also need to set a class default for this ability - use the dropdown menu and choose DebugTestAbility for StartingAbility. This should be enough to give the debug test ability to the player character.

Finally, we need to put in a way to actually activate the ability. Open up your Project Settings and go to Input. Add a new action mapping and call it UseAbility1. Assign it to something. In this case, I’ve I’ve assigned it to a gamepad button.

Now... in the PlayerCharacter blueprint, we’ll put in a quick test function for this. Add a new Event InputAction UseAbility1, and for “Pressed” you can put a printstring (to make sure the input is being registered), followed by TryActivateAbilitiesByTag. The Target should be the inherited Ability System Component. Then you just need an array of gameplay tag containers. We do that by doing MakeLocalGameplayTag (choosing the tag we added above - Debug.Test.DebugTestAbility), MakeArray on it, then MakeGameplayTagContainerFromArray, and feeding that into the GameplayTagContainer input field on TryActivateAbilitiesByTag.

Compile your blueprints and run. You should be able to move around and pressing the UseAbility1 button should print a string to the screen that matches what we set in DebugTestAbility.

Congratulations everybody, FANTa has begun (again). We’ve set up our character and our gameplay ability system with one working ability! Future posts will be a little less in the nitty gritty as we become more familiar with the UE interface and I’ll focus more on the principles of what we’re doing rather than the exact details of the implementation. If you’re having trouble getting set up or following, please ask in #fanta-discussion on our discord server! I also want to thank all of our patrons on Patreon for helping to make this possible. We really appreciate your support.

[Join us on Discord] and/or [Support us on Patreon]

We’ve started the FANTa project in Unreal. [What is the FANTa project?]

Got a burning question you want answered?

Short questions: Ask a Game Dev on Twitter

Long questions: Ask a Game Dev on Tumblr

It’s been a while, but that’s primarily because of the larger scope of this particular update. We asked our patrons what we should do, and they voted to add a fair amount of functionality to the Gameplay Ability System that we set up in the last update. 

The things we’re looking to do this time around are:

Keep track of what abilities a character’s active Abilities are

Create a way for us to determine the targets so one ability can hit multiple other actors (e.g. PBAOE, self-buff, etc.)

Add the ability to play an animation and wait for a specific game event triggered during that animation

This will enable us to do things like basic combat, spells like a fireball, and also things like self-buffs (e.g. giving the player the ability to jump higher or heal). This code is primarily adapting from [Epic’s free Action RPG resource]. Action RPG is a learning resource that’s very helpful, but we can’t just directly copy and paste code and blueprints; there’s a lot of dependencies there that exist under the hood. We need to bring over some of their stuff to FANTa, and that’s going to require some additional code work.

Fair warning - due to the scope of code changes, I’m going to be simplifying some of the description of what’s being done. I’ll make the code repository available via [google drive here] if you want to get it. If you do get this code, you’ll need to re-generate your C++ files by double clicking the FANTa unreal engine project file after getting the code into the appropriate places. This may end up overwriting some of your other code changes (especially if you’ve done anything else to your version of FANTa in the meantime). So let’s go to it, shall we?

#1: Create our own FANTaAbilitySystemComponent

Reference file: Abilities/FANTaAbilitySystemComponent

We’re creating a new FANTaAbilitySystemComponent that inherits from AbilitySystemComponent. It does all the same stuff as the base AbilitySystemComponent, but also has some additional functionality. Specifically, we want to add a function called GetActiveAbilitiesWithTags which will return a container of ActiveAbilities that match the gameplay tags being passed in, a function to get the Default Ability Level (for abilities that have more than one level), and a static function to get the FANTaAbilitySystemComponent from a specific actor if it exists.

In addition to this new component, we also need to change the AbilitySystem variable in FANTaCharacter to be of FANTaAbilitySystemComponent type instead of the old AbilitySystemComponent type. This will be necessary later, when our montage ability task tries to get the appropriate ability component from the player.

#2: Create our Targeter

Reference File: FANTaTargetType

We’re creating a new UObject here called a FANTaTargetType which will function as a target-getter. It will run some logic that will return a list of valid targets. We can use the base functionality to create sub-targeters like a circular AOE, a character-based AOE, a self-buff, and so on. It’s important to make this Blueprintable so that we can make blueprints that derive from this class. We also created two subclasses of this - TargetType_UseOwner (for abilities that target oneself) and TargetType_UseEventData if there’s already targets defined in the Gameplay Event Data.

#3: Create our Gameplay Effect Containers

Reference file: FANTaAbilityTypes

We’re also creating a set of structs. This will be a little odd since we’re not actually able to do this via the editor (since we’re not creating a new C++ class), but you can get Unreal Engine to do it for you anyway by having it #include “HeaderName.generated.h” and it will still do it for you after you re-generate your C++ project files. Specifically, what we’re doing here is creating two structs that will keep track of a Targeter and a batch of associated Gameplay Effects. The first struct takes a specific targeter and a list of Gameplay Effects to apply. The second is generated when we instantiate the first and keeps track of all of the effects and targets (and also has the ability to add additional targets). This is necessary for the next step we’re doing, which is to create our own FANTa Gameplay Ability base class.

#4: Create our own FANTa Gameplay Ability base class

Reference file: Abilities/FANTaGameplayAbility

This is the crux of what we’re doing. We’re making our own Gameplay Ability that has several blueprint callable functions, specifically in relation to the effect containers we did in #3. Our gameplay ability will be able to take a container or a container spec (i.e. targeter and effect data) and then apply those effects to the targets specified by the targeter. These are all Blueprint callable so that we can create subclasses of the FANTaGameplayAbility and use this functionality.

#5. Create a Gameplay Ability Task that plays a montage and listens for gameplay events 

Reference file: Abilities/FANTaTask_AnimMontage_WaitEvent

The animations we’ll be using from blueprints are called Montages. We create an Ability Task - that’s a Gameplay Ability-specific subroutine that runs asynchronously from the Ability and then can call Delegates when events happen inside. What our code will do is create a new Blueprint function called Play Montage and Wait for Event that we can call from within our FANTa Gameplay Ability. This will allow us to play an animation montage and then, when certain things happen like a specific keyframe is hit, we’ll notify the ability and do something cool (like cause an explosion, heal the player, spawn a projectile, or play a particle effect).

Woof, that’s a lot of ground to cover if you want to follow along. Thankfully, even if you don’t know your C++ super well, you can probably unzip the source into the folder by overwriting everything, re-generate your C++ project files by double clicking the FANTa Unreal Engine Project File, and be able to compile and run ok. If you’re having trouble following along, please visit our [discord server] and post in the #fanta-discussion channel. Next time we’ll put together an ability in blueprints using this new tech. 

[Join us on Discord] and/or [Support us on Patreon]

The FANTa Project is being rebooted. [What is the FANTa project?]

Got a burning question you want answered?

Short questions: Ask a Game Dev on Twitter

Long questions: Ask a Game Dev on Tumblr