Generic Activity Framework

Generic backbone framework for hierarchical activity ownership, processing and result handling

Download from Marketplace

GitHub

Use case

Gameplay • Project boilerplate

Module specifications

Runtime • Default Loading Phase
Editor • Default Loading Phase

Modules

Generic Activity Runtime

Generic Activity Editor

Dependencies

Prerequisite information

Get familiar with these topics beforehand

What are 'typed' gameplay tags in C++?

Become familiar with 'typed' gameplay tags, and understand why it's used by almost all plugins on ubyte.dev.

What are GameplayTag Base/Remap Categories?

Become familiar with GameplayTag Base/Remap Categories, and understand why their usage is desire.

Plugin overview

Branch main

The Generic Activity Framework is a collection of interlinked boilerplate C++ classes that set the stage for scalable hierarchical activity processing using GameplayTags.

The framework primarily wants to:

Scaffold other, more opinionated systems that also agree with this world-crowd-agent style hierarchical activity execution approach.

Maintain a rich degree of possible static usage contexts while not being overly generic.

Provide channels of extensibility with something ubyte.dev calls GameplayConcepts.

IGenericWorldActivityWorker

Backbone for all FWorldActivity workers

IGenericCrowdActivityWorker

Backbone for all FCrowdActivity workers

IGenericAgentActivityWorker

Backbone for all FAgentActivity workers

Beginning/ending activities

In short, there are 3 main interfaces: IGenericAgentActivityWorker, IGenericCrowdActivityWorker and IGenericWorldActivityWorker. Each of them are able to begin activities, which are expressed as GameplayTags.

From this framework’s perspective, only the following is known:

IGenericAgentActivityWorker runs a FAgentActivity one at the time (non-virtual). The actual implementation of the activity itself is delegated to a pure virtual impl method.

The framework does not preconceive what these activities actually mean. For example, IGenericAgentActivityWorker only knows and manages the beginning/ending of an FAgentActivity without further inclinations.

Likewise, IGenericCrowdActivityWorker can only run a FCrowdActivity, and IGenericWorldActivityworker only a FWorldActivity.

FWorldActivity

Structure describing a performable world activity

FCrowdActivity

Structure describing a performable crowd activity

FAgentActivity

Structure describing a performable agent activity

/** Backbone for all FAgentActivity workers */
class GENERICACTIVITYRUNTIME_API IGenericAgentActivityWorker
{
	GENERATED_BODY()
...
public:
	/** Process a new AgentActivity */
	void BeginAgentActivity(const FAgentActivity& InAgentActivity);

	/** Immediately stop the current AgentActivity */
	void EndAgentActivityImmediately();
...
private:
	/** Implementation body of BeginAgentActivity */
	virtual void BeginAgentActivityImpl(const FAgentActivity& InAgentActivity) = 0;
...
};

IGameplayLocationQuerier

Interface for getting FVectors from GameplayTags.

UGameplayLocationSettings

Settings tunable inside Project Settings

Cognition tags

Each activity worker has methods for keeping their own Scoped/Persistent Cognition tags, which are GameplayTags mapped to a specific base category. They may encapsulates anything from knowledge, reasoning, to memory.

Scoped Cognition tags are automatically removed when the current activity ends.
Persistent Cognition tags remain unless manually removed.

ubyte.dev endorses creating GameplayConcepts extending Cognition that:

Explicitly specify which problem they solve. Example: WorkerStrategyGameplayConcept (included by default) introduces a filtered variant of Cognition called Strategy. The concept mandates that these always dynamically influence the underlying implementation of an activity.

Explicitly manage their blueprint exposure. Example: WorkerStrategyGameplayConcept introduces BlueprintCallable methods for adding/removing Strategy tags.

Blueprints should never be able to add/remove unencapsulated cognition tags. It's only permitted through blueprint-exposed concepts that extend cognition (e.g. Strategy).

FWorldActivityCognitionTag

Tag that encapsulates cognition for WorldActivityWorkers specifically

FCrowdActivityCognitionTag

Tags that encapsulate cognition for CrowdActivityWorkers specifically

FAgentActivityCognitionTag

Tags that encapsulate cognition for AgentActivityWorkers specifically

UGameplayLocationManager

Engine subsystem with BlueprintCallable methods aiding FGameplayLocation

Download from Marketplace

GitHub