Boil and Bubble, Brew and Bottle…

Factory Method
GoF says the intent of the Factory Method is to “define an interface for
creating an object, but let subclasses decide which class to instantiate”
(Gamma et.al, 1995). The Factory Method invokes another important object-
oriented principle. That principle is called “Dependency Inversion”. We want
subclasses to depend on abstractions and not the other way around. Basically,
we want children to depend on their parents.

The Good
● Encapsulate instantiation
● Concrete products are not coupled to their creator

The Not So Good

● Can create difficult to follow code because of the level of
abstraction.

Factory Method Implementation

We have creator, concrete creator, and product participants in the Factory
Method design pattern. Our example implementation has a PotionShop
abstract class as a creator. The concrete creators are InnerRealmPotionShop
and OuterRealmPotionShop. These concrete creators inherit functionality
from the PotionShop abstract class. Our concrete products are:

InnerRealmHealthPotion
InnerRealmPowerPotion
InnerRealmSkillPotion
OuterRealmHealthPotion
OuterRealmPowerPotion
OuterRealmSkillPotion

All these products inherit functionality from the Potion abstract class.
Using blueprints, we are going to implement the InnerRealmPotionShop and
its products, namely:

InnerRealmHealthPotion
InnerRealmPowerPotion
InnerRealmSkillPotion

The same ideas and principles apply to the creation of the

OuterRealmPotionShop and its products.

The FactoryMethod class contains the main function. In terms of

Blueprints, we can think of this class as the one that needs to be physically
dragged into the game world. The other “concrete” classes do not need to be
physically dragged into the world.
 FactoryMethod_Main.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "FactoryMethod_Main.generated.h"

UCLASS()
class DESIGN_PATTERNS_API AFactoryMethod_Main : public AActor
{
GENERATED_BODY()

public:
// Sets default values for this actor's properties
AFactoryMethod_Main();

protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;

public:
// Called every frame
virtual void Tick(float DeltaTime) override;

};
 FactoryMethod_Main.cpp

#include "FactoryMethod_Main.h"
#include "OuterRealmPotionShop.h"
#include "InnerRealmPotionShop.h"

// Sets default values

AFactoryMethod_Main::AFactoryMethod_Main()
{
// Set this actor to call Tick() every frame. You can turn this off to
improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;

// Called when the game starts or when spawned

void AFactoryMethod_Main::BeginPlay()
{
Super::BeginPlay();

//Create the Shops

APotionShop* OuterRealmShop = GetWorld()-
>SpawnActor<AOuterRealmPotionShop>
(AOuterRealmPotionShop::StaticClass());
APotionShop* InnerRealmShop = GetWorld()-
>SpawnActor<AInnerRealmPotionShop>
(AInnerRealmPotionShop::StaticClass());

//Create an Outer Health Potion and log its name

APotion* Potion = OuterRealmShop->OrderPotion("Health");
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));

//Create an Inner Health Potion and log its name

Potion = InnerRealmShop->OrderPotion("Health");
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));
 //Create an Outer Power Potion and log its name
Potion = OuterRealmShop->OrderPotion("Power");
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));

//Create an Inner Health Potion and log its name

Potion = InnerRealmShop->OrderPotion("Power");
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));

//Create an Outer Skill Potion and log its name

Potion = OuterRealmShop->OrderPotion("Skill");
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));

//Create an Inner Health Potion and log its name

Potion = InnerRealmShop->OrderPotion("Skill");
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));
}

// Called every frame

void AFactoryMethod_Main::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);

}
This is the top-level event graph for the FactoryMethod_Main blueprint:

The Create Shops collapsed graph:

The Create Outer HP blueprint:

The Create Inner HP blueprint:

The Create Outer PP blueprint:

The Create Inner PP blueprint:

The Create Outer SP blueprint:

The Create Inner SP blueprint:

 Basically, we are ordering different potions from the Potion Shops and
then printed information related to the potion we ordered.

These graphs are equivalent to:

Potion = InnerRealmShop->OrderPotion("Health");

GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,

FString::Printf(TEXT("Potion is %s"), *Potion->GetPotionName()));

The create inner/outer potion collapsed graphs all contain the same
functionality with a different potion being ordered:

This concludes the FactoryMethod_Main blueprint. Next, we move on to

the Potion and PotionShop classes. Both of these classes are abstract. We can
create abstract classes in blueprints by navigating to class settings and
checking “Generate Abstract Class.” As pictured here:

Our PotionShop class code implementation:

 PotionShop.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Potion.h"
#include "PotionShop.generated.h"

UCLASS()
class DESIGN_PATTERNS_API APotionShop : public AActor
{
GENERATED_BODY()

public:
// Sets default values for this actor's properties
APotionShop();

protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;

public:
// Called every frame
virtual void Tick(float DeltaTime) override;

//Create Potion and returns it. It's pure virtual, so it doesn't need an
implementation in this class
virtual APotion* ConcoctPotion(FString PotionSKU)
PURE_VIRTUAL(APotionShop::ConcoctPotion, return nullptr;);

//Order, concoct and returns a Potion of a specific Category

APotion* OrderPotion(FString Category);

};
PotionShop.cpp

#include "PotionShop.h"

// Sets default values

APotionShop::APotionShop()
{
// Set this actor to call Tick() every frame. You can turn this off to
improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;

// Called when the game starts or when spawned

void APotionShop::BeginPlay()
{
Super::BeginPlay();

// Called every frame

void APotionShop::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);

APotion* APotionShop::OrderPotion(FString Category)

{
//Create the Potion and log its name
APotion* Potion = ConcoctPotion(Category);
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Concocting %s"), *Potion->GetPotionName()));

//Start the concoct process

Potion->Boil();
Potion->Bubble();
Potion->Brew();
 Potion->Bottle();

//Returns the created potion

return Potion;
}
 Here we must deviate a bit from traditional code. There does not seem to
be a way to explicitly declare a function as “abstract” in blueprints. It is
possible that the compiler may be smart enough to do this under the hood, but
there is no public information stating this feature. Our ConcoctPotion
equivalent blueprint:

The OrderPotion function blueprint:

The Prepare Potion collapsed graph:

 The GetPotionName Boil, Bubble, Brew and Bottle are in the Potion
class. Here is the Potion class code implementation:
 Potion.h

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Potion.generated.h"

UCLASS()
class DESIGN_PATTERNS_API APotion : public AActor
{
GENERATED_BODY()

public:
// Sets default values for this actor's properties
APotion();

protected:

//The name of this Potion

FString PotionName;

//The Gooeyness of this Potion

FString Gooeyness;

//The Blood of this Potion

FString Blood;

//The herbs contained in this Potion

TArray<FString> Herbs;

protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;

public:
// Called every frame
virtual void Tick(float DeltaTime) override;
 //Boild this potion
void Boil();

//Bubble this potion

void Bubble();

//Brew this potion

virtual void Brew();

//Bottle this potion

void Bottle();

//Return the Potion Name

FString GetPotionName();
};
 Potion.cpp

#include "Potion.h"

// Sets default values

APotion::APotion()
{
// Set this actor to call Tick() every frame. You can turn this off to
improve performance if you don't need it.
PrimaryActorTick.bCanEverTick = true;

Herbs = TArray<FString>();

// Called when the game starts or when spawned

void APotion::BeginPlay()
{
Super::BeginPlay();

// Called every frame

void APotion::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);

void APotion::Boil()
{
//Log the Boil procedure
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
FString::Printf(TEXT("Boil %s"), *GetPotionName()));
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Drop in blood..."));
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Drop in herbs: "));
}

void APotion::Bubble()
{
//Log the Bubble procedure
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Bubble for 3 moons and a sunset"));
}

void APotion::Brew()
{
//Log the Brew procedure
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Brewing at Low Temperature"));
}

void APotion::Bottle()
{
//Log the Bottle procedure
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Bottle concoction in flask"));
}

FString APotion::GetPotionName()
{
//Return the name of this Potion
return PotionName;
}
The Boil method equivalent blueprint function:

The Bubble method equivalent blueprint function:

The Brew method equivalent blueprint function:

 The Bottle method equivalent blueprint function:

The GetPotionName method equivalent blueprint function:

Now that we have our abstract parent classes defined let’s focus on the
concrete creator

The InnerRealmPotionShop concrete creator class:

 InnerRealmPotionShop.h

#pragma once

#include "CoreMinimal.h"
#include "PotionShop.h"
#include "InnerRealmPotionShop.generated.h"

UCLASS()
class DESIGN_PATTERNS_API AInnerRealmPotionShop : public
APotionShop
{
GENERATED_BODY()

public:

//Concoct the selected potion

virtual APotion* ConcoctPotion(FString PotionSKU) override;

};
 InnerRealmPotionShop.cpp

#include "InnerRealmPotionShop.h"
#include "InnerRealmHealthPotion.h"
#include "InnerRealmPowerPotion.h"
#include "InnerRealmSkillPotion.h"

APotion* AInnerRealmPotionShop::ConcoctPotion(FString PotionSKU)

{
//Select which potion to spawn depending on the passed string
if (PotionSKU.Equals("Health")) {
return GetWorld()->SpawnActor<AInnerRealmHealthPotion>
(AInnerRealmHealthPotion::StaticClass());
}
else if (PotionSKU.Equals("Power")) {
return GetWorld()->SpawnActor<AInnerRealmPowerPotion>
(AInnerRealmPowerPotion::StaticClass());
}
else if (PotionSKU.Equals("Skill")) {
return GetWorld()->SpawnActor<AInnerRealmSkillPotion>
(AInnerRealmSkillPotion::StaticClass());
}
else return nullptr; //Return null if the string isn't valid
}
 The InnerRealmPotionShop blueprint consists of only the ConcoctPotion
function:

The Spawn Inner Health Potion collapsed graph:

The Spawn Inner Power Potion collapsed graph:

 The Spawn Inner Skill Potion collapsed graph:

Now that we have our concrete creator class defined let’s focus on the
concrete products this creator can create.

The InnerRealmHealthPotion concrete product class:

 InnerRealmHealthPotion.h

#pragma once

#include "CoreMinimal.h"
#include "Potion.h"
#include "InnerRealmHealthPotion.generated.h"

UCLASS()
class DESIGN_PATTERNS_API AInnerRealmHealthPotion : public
APotion
{
GENERATED_BODY()

protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;

public:

//Brew the potion

virtual void Brew() override;

};
 InnerRealmHealthPotion.cpp

#include "InnerRealmHealthPotion.h"

void AInnerRealmHealthPotion::BeginPlay()
{
Super::BeginPlay();

//Set the ingredients

PotionName = "Inner Realm Health Potion";
Gooeyness = "Mucus Like";
Blood = "Orc Blood";

//Add the herbs

Herbs.Add("Root of Inner Realm");
}

void AInnerRealmHealthPotion::Brew()
{
//Log the brewing type
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Brewing at High Temperature"));
}
The InnerRealmHealthPotion blueprint event graph and a brew event:

The InnerRealmPowerPotion concrete product class:

 InnerRealmPowerPotion.h

#pragma once

#include "CoreMinimal.h"
#include "Potion.h"
#include "InnerRealmPowerPotion.generated.h"

UCLASS()
class DESIGN_PATTERNS_API AInnerRealmPowerPotion : public
APotion
{
GENERATED_BODY()

protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;

public:

//Brew the potion

virtual void Brew() override;
};
 InnerRealmPowerPotion.cpp

#include "InnerRealmPowerPotion.h"

void AInnerRealmPowerPotion::BeginPlay()
{
Super::BeginPlay();

//Set the ingredients

PotionName = "Inner Realm Power Potion";
Gooeyness = "Mucus Like";
Blood = "Orc Blood";

//Add the herbs

Herbs.Add("Root of Inner Realm");
Herbs.Add("Sage of Inner Realm");
}

void AInnerRealmPowerPotion::Brew()
{
//Log the brewing type
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Brewing at High Temperature"));
}
The InnerRealmPowerPotion blueprint event graph and a brew event:

The InnerRealmSkillPotion concrete product class:

 InnerRealmSkillPotion.h

#pragma once

#include "CoreMinimal.h"
#include "Potion.h"
#include "InnerRealmSkillPotion.generated.h"

UCLASS()
class DESIGN_PATTERNS_API AInnerRealmSkillPotion : public APotion
{
GENERATED_BODY()

protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;

public:

//Brew the potion

virtual void Brew() override;

};
 InnerRealmSkillPotion.cpp

#include "InnerRealmSkillPotion.h"

void AInnerRealmSkillPotion::BeginPlay()
{
Super::BeginPlay();

//Set the ingredients

PotionName = "Inner Realm Skill Potion";
Gooeyness = "Mucus Like";
Blood = "Orc Blood";

//Add the herbs

Herbs.Add("Root of Inner Realm");
Herbs.Add("Red Clover of Inner Realm");
Herbs.Add("Wildrose of Inner Realm");
Herbs.Add("Yarrow of Inner Realm");
}

void AInnerRealmSkillPotion::Brew()
{
//Log the brewing type
GEngine->AddOnScreenDebugMessage(-1, 15.f, FColor::Yellow,
TEXT("Brewing at High Temperature"));
}
 The InnerRealmSkillPotion blueprint event graph and a brew event:

We can easily add another concrete creator class like

OuterRealmPotionShop and create more concrete products using the same
inheritance methods as the InnerRealmPotionShop:

The OuterRealmPotionShop class:

 OuterRealmPotionShop.h
#pragma once

#include "CoreMinimal.h"
#include "PotionShop.h"
#include "OuterRealmPotionShop.generated.h"

UCLASS()
class DESIGN_PATTERNS_API AOuterRealmPotionShop : public
APotionShop
{
GENERATED_BODY()

public:

//Concoct the selected potion

virtual APotion* ConcoctPotion(FString PotionSKU) override;

};
 OuterRealmPotionShop.cpp

#include "OuterRealmPotionShop.h"
#include "OuterRealmHealthPotion.h"
#include "OuterRealmPowerPotion.h"
#include "OuterRealmSkillPotion.h"

APotion* AOuterRealmPotionShop::ConcoctPotion(FString PotionSKU)

{
//Select which potion to spawn depending on the passed string
if (PotionSKU.Equals("Health")) {
return GetWorld()->SpawnActor<AOuterRealmHealthPotion>
(AOuterRealmHealthPotion::StaticClass());
}
else if (PotionSKU.Equals("Power")) {
return GetWorld()->SpawnActor<AOuterRealmPowerPotion>
(AOuterRealmPowerPotion::StaticClass());
}
else if (PotionSKU.Equals("Skill")) {
return GetWorld()->SpawnActor<AOuterRealmSkillPotion>
(AOuterRealmSkillPotion::StaticClass());
}
else return nullptr; //Return null if the string isn't valid
}
 We would implement some OuterRealmPotionShop concrete products in
a similar fashion as the concrete products of the InnererRealmPotionShop :

The Factory Method viewport print: