Today we resume our C++ Fundamentals lessons by looking at interfaces and how they can help simply our life by allowing for common contracts to be shared by different game actors.
Tags are essentially a collection of strings that can be applied to an Actor or an Actors Component and then referenced by other Actors or parts of the game world by those tags.
Very similar to using tags on a blog to include metadata for search engines to query … like this blog !
Tags ?! We don’t need to no stinking tags !
Sure you do, and they are really easy to use which is why this post is going to be super short.
Take a look, in this case we are displaying all tags for a specific actor.
// iterate over all of our actors
for(TActorIterator<AActor> ActorIterator(GetWorld()); ActorIterator; ++ActorIterator)
{
AActor* Actor = *ActorIterator;
// ensure actor is not null
// ignore self if found
// ensure we find actors of a specific interface only
if(Actor && Actor != this && Actor->GetClass()->ImplementsInterface(UInteractiveActor::StaticClass()))
{
// display all available tags for an actor
for(FName Tag : Actor->Tags)
{
GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Cyan, Tag.ToString());
}
}
}
We can also just check for a specific tag without iterating over all of them by using ActorHasTag method.
Today we resume our C++ Fundamentals lessons by looking at interfaces and how they can help simply our life by allowing for common contracts to be shared by different game actors.
An interface is an abstract definition of a contract. What this means is an interface defines how our class can be interfaced ( hah ! ) with while keeping the implementation details away.
More than that it allows us to create a common method signature between various disparate objects.
Consider I have an interface that has a method on it called “DoStuff” and I have two objects, Dog and Person, that inherit this interface. When I call Dog->DoStuff he may perform a trick while if I call the same method of Person->DoStuff he may tell me to fuck off and to stop bothering them. But from the point of view of the code interacting with those actors it’s the same behavior.
This allows for a lot of re-use and generic implementations while keeping the details of those implementations specific.
This all seems very abstract, show me code !
So let’s take a look at how an interface class is structured
UINTERFACE(MinimalAPI)
class UInteractiveActor : public UInterface
{
GENERATED_BODY()
};
/**
*
*/
class UE4FUNDAMENTALS09_API IInteractiveActor
{
GENERATED_BODY()
// Add interface functions to this class. This is the class that will be inherited to implement this interface.
public:
UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category = "Interact")
void Interact();
};
As you can see it’s pretty thin in definition, we simply have a class that inherits from UInterface and then defines the method signature of “Interact”.
Excellent now we are cooking with fire, now what ?
Once we have the interface in place we now start including it on our objects. Let’s take a look at our InteractiveProp.
UCLASS()
class UE4FUNDAMENTALS09_API AInteractiveProp : public AActor, public IInteractiveActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
AInteractiveProp();
UPROPERTY(VisibleAnywhere, BlueprintReadWrite, Category = "Interact")
class UStaticMeshComponent* BaseMesh;
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
public:
// Called every frame
virtual void Tick(float DeltaTime) override;
UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category = "Interact")
void Interact(); // prototype declaration
virtual void Interact_Implementation() override; // actual implementation of our interact method
private:
bool bIsBig;
};
The major thing to note is that in order to leverage the interface, we modify our class signature to bring in “IInteractiveActor”
class UE4FUNDAMENTALS09_API AInteractiveProp : public AActor, public IInteractiveActor
Then we overwrite the Interact method by first declaring the prototype method signature and then the implementation one. Please note that the “_Implementation” is important and has to be exact for the reflection mechanic in Unreal to process your interface + implementation.
We are going to continue our C++ Fundamentals lessons by creating a custom HUD using AHUD class, then adding a custom widget to the HUD using UUserWidget and finally rounding things off by adding some UWidgetAnimations to make the whole thing look a bit more pretty.
As usual you can find the starter project on our GitHub page.
Hold up, lets get some background on all this stuff first !
HUD – heads.up.display. this is a way of projecting various bits of information in the form of text, images, animations, etc to inform the player as to what is happening to him, other things, or his environment.
Alternatively a hud can also represent menu screens, credits, etc.
Essentially they are the large canvas on which various components and widgets will be displayed on.
For example:
– hud that show cases all the player attributes like health, mana and stamina
– options menu for configuring graphics properties
– scrolling credits
User Widget – a single purpose component that you can attach to various locations on the hud as well as the view port. this is normally either a single “ui thing” or a logical grouping of “ui things”.
For example:
– a cross hair in a FPS game
– health and mana bars on top of each other
– speed gauge in a car sim
Widget Animation – are user widget components responsible for handling the animation for all the various components added to the user widget.
This includes manipulation of states like transformation, visibility, color and opacity. Which allows designers to create various fun and exciting ways of presenting data and feedback to the player.
Example:
– health bar is actually red liquid that boils away as the player takes damage
– damage indicators that show up when a player hits something and proceed to fall to the ground while fading away
That’s better, now what ?
Well lets take a look at our HUD class and what we can do with it.
Similar layout to our player or prop classes but you get a few extra functions like DrawHUD() that allows you to control the various aspects of screen components and widgets.
We also include a TSubclassOf<UUserWidget> that allows us to include various custom widget components as part of this HUD.
void AInGameHUD::BeginPlay()
{
Super::BeginPlay();
if (HitComboWidgetClass)
{
HitComboWidget = CreateWidget<UHitComboWidget>(GetWorld(), HitComboWidgetClass);
/** Make sure widget was created */
if (HitComboWidget)
{
/** Add it to the viewport */
HitComboWidget->AddToViewport();
}
}
}
The important method here is the one that instantiates the custom widget class and adds it to our view port.
void AInGameHUD::UpdateComboCount(int32 Value)
{
if (HitComboWidget)
{
HitComboWidget->UpdateComboCount(Value);
}
}
This is just an example of how we would call our user widget via our hud.
Great we have a HUD but what else do we need ?!
So let’s examine our user widget to see what makes it tick.
As we can see in the header the deafult constructor for a UUserWidget is a bit different as it expects an ObjectInitializer to be passed in.
We also don’t have a BeginPlay but rather we expose NativeConstruct which esentially behaves the same way and loads stuff after the constructor is already loaded.
UPROPERTY(EditAnywhere, BlueprintReadWrite, meta = (BindWidget))
class UTextBlock* TXTCombo;
This bit here allows us to auto bind by name to a component on the user widget. In this case we are looking for a UTextBlock of name TXTCombo.
[ insert warning image ]
NOTE: You will get warnings if these attributes are not present.
In the native construct we do a few things, we first use the StoreWidgetAnimations function to populate a map of animations keyed by name.
We then use that data to populate our animation variables by their names of ComboFade and ComboShake respectively.
void UHitComboWidget::UpdateComboCount(int32 Value)
{
// only update if more than one hit
if (TXTCombo && Value > 1)
{
if (TXTCombo->Visibility == ESlateVisibility::Hidden)
{
TXTCombo->SetVisibility(ESlateVisibility::Visible);
}
TXTCombo->SetText(FText::FromString((FString::FromInt(Value) + "x Combo")));
if (ComboShakeAnimation)
{
PlayAnimation(ComboShakeAnimation, 0.f, 1, EUMGSequencePlayMode::Forward, 1.f);
}
if (ComboFadeAnimation)
{
PlayAnimation(ComboFadeAnimation, 0.f, 1, EUMGSequencePlayMode::Forward, 1.f);
}
}
}
In this method, we manipulate the state of the TXTCombo viability based on it being reset and set it back to visible.
We also take in the user provided combo count and add it to the text.
Once that is in place we play back the two animations, one to shake the text and the other to fade it away after a few seconds.
In this method we reset the visibility of the TXTCombo back to hidden.
void UHitComboWidget::StoreWidgetAnimations()
{
AnimationsMap.Empty();
UProperty* Prop = GetClass()->PropertyLink;
// check each property of this class
while (Prop)
{
// only evaluate object properties, skip rest
if (Prop->GetClass() == UObjectProperty::StaticClass())
{
UObjectProperty* ObjProp = Cast<UObjectProperty>(Prop);
// only get back properties that are of type widget animation
if (ObjProp->PropertyClass == UWidgetAnimation::StaticClass())
{
UObject* Obj = ObjProp->GetObjectPropertyValue_InContainer(this);
// only get back properties that are of type widget animation
UWidgetAnimation* WidgetAnimation = Cast<UWidgetAnimation>(Obj);
// if casting worked update map with new animation
if (WidgetAnimation && WidgetAnimation->MovieScene)
{
FName AnimName = WidgetAnimation->MovieScene->GetFName();
GEngine->AddOnScreenDebugMessage(-1, 4.5f, FColor::Magenta, AnimName.ToString());
AnimationsMap.Add(AnimName, WidgetAnimation);
}
}
}
Prop = Prop->PropertyLinkNext;
}
}
This is the big method that allows us to process each property of the current user widget and evaluate them for widget animations.
When a widget animation is found we update our private map with those details.
Well lets take a look at our HUD class and what we can do with it.
So let’s examine our user widget to see what makes it tick.