GGameUtils Tutorial System

Overview

Made for Unreal Engine 5 using C++, this is a plugin for people to make managed and saved tutorials with, and/ or to extend for your game's specific tutorial purposes. Currently available for free on FAB.

Engine Implementation

Unreal 5 C++, UE5 Plugin

In past projects, for one reason or another, we have often focused on tutorials late into the project, and while we've gotten to results that give the info they need, they almost always are grating in parts, or more importantly, need more iteration to achieve the consistency of teaching players that we'd like. So, while this plugin may not make people to read the text on the screen as you really want them to, my goals with this plugin were to create a tutorial system that could support a variety of basic tutorials easily, as well as some dynamic tutorials that more specifically fit the needs of a project, and individual players. So, using the tools this gives, it enables a much quicker start to the iteration needed to make sure players still get the info they need, one way or another.

For example, a movement tutorial that only pops up if the player hasn't moved for a while after they spawn, letting familiar players get on with it, but ensuring newer players know the controls for moving.

With this, polished tutorials will likely need specific logic that requires custom implementations, and a lot more tuning on the visual style, both of which take time and iteration that there isn't much subsitute for. So, this plugin gives multiple places to build that custom logic and style.

And, the iteration to achieve that is easier when spread out across the development cycle, and I believe the tutorial creation options I came up with will be helpful to give people a jump start on making tutorials, meaning that even teams with 20 minutes to spare here and there can slot this in to start giving their playtesters in-game tutorials. And, if they do this early on, ideally they will learn much more throughout development about how to make better tutorials for their players, taking playtester reactions to their tutorials from "aww... a tutorial", to "Ah! I see..."

Check it out!

The plugin is available for free on the FAB store here: https://www.fab.com/listings/e4bc4ec0-a632-46c3-a633-4e65e5343ed3

How does it work?

The details of how tutorials work can vary decently per game, but to make a system that could work for a variety of games, I found that there were 3 main things most tutorials needed:

Logic for triggering the tutorial
Logic for completing the tutorial
Making a popup for the tutorial, and controlling what it looks like

Points 1 and 2, Tutorial Logic

To support trigger and completion logic, I created 3 main methods of making conditions, to give options that could be contained entirely in the tutorial system for those that preffered that approach, automatically managing the conditions and keeping them mostly separate from game logic, but also allow people to control the state of tutorials using their existing code.

First, the user creates a tutorial blueprint for the particular tutorial, and then they can choose from these options for creating tutorial trigger/ completion logic:

Method 1: Tutorial Class Function Overriding

Inside each tutorial blueprint (or C++) class, the user can override a function to tell when the tutorial should activate, and one for when it should complete itself, which get checked for automatically during gameplay

EX: Low health tutorial

In this case, we may want to trigger the tutorial when the player is under a certain threshold of health, and finish the tutorial when they are above it, meaning they've healed and now know how to heal.

First, one the tutorial is set up, this condition is being checked for while playing

Once triggered, it brings in the tutorial popup

Which goes away when the complete condition of healing above a health threshold is met

Using this method of overriding the tutorial blueprints lets the user easily slot in tutorials without adding calls into existing logic, which can be nice for working under write locks, and just can generally help with code separation, and quickly making new tutorials.

It may not always be the correct approach, especially if you have a ton of tutorials, and don't want them all to be checking each frame until they are completed, but it provides a way for tutorials to be managed automatically. And, if a more manual approach is preferred, for performance if it comes up, or to add tutorials calls to existing areas of logic that might be used as the tutorial conditions, methods 2 and 3 are made just for that.

Method 2: Direct Calls Through the Tutorial Monitor Component

Whether attached to your player or player controller, the tutorial monitor is where the user sets the tutorials they wish to use, and they can call functions from it to manually trigger or complete tutorials.

EX: How to Shoot Tutorial

For this example, we could give the player a weapon, and want a tutorial showing the buttons to fire it to stay up until the weapon is fired, to make sure the player knows how to shoot

Using the function on the tutorial monitor, we could use the area of code that equips the weapon to also trigger the shoot tutorial

Then, the shoot tutorial will pop up as soon as the player has the weapon

Then, the user can call the matching "Try Queue Tutorial Complete" function on the tutorial monitor to complete the tutorial.

Or, if a more event-based approach is preferred/ more suited to the situation, such as responding an event that triggers when fired, method 3 lets you use delegates/ event dispatchers to trigger and complete tutorials as well.

Method 3: Binding Triggers To Event Dispatchers

While slightly more advanced, event dispatchers (and C++ delegates) can be a great middle ground between separating tutorial code and gameplay logic, and reusing existing logic to trigger tutorials. And, the tutorial monitor provides delegates that can be bound to event dispatchers, to trigger/ complete tutorials in response to the event.

EX: Completing the shoot tutorial in response to a shoot event

If the user has an event that triggers when firing occurs, or wants to create one, then it can be subscribed to to trigger the completion of the examaple shoot tutorial from above in method 2.

Once binding to the event (and adding logic to broadcast the event when firing the weapon, if the event didn't already exist), whenever shooting occurs, it will invoke the event, which finishes the tutorial and makes it slide off the screen.

Just like the other 2 logic methods, the same thing can be done in C++, for example like this:

Through a combination of automanically managed conditions, calling tutorial triggers directly, and binding to events, tutorials can be triggered in ways that should fit most projects, either by letting logic be easily created separately from gameplay code, or added right into existing code, to start testing and improving tutorials.

Tutorials in Action

Point 3, Tutorial Popup and Style

As for the last point of what tutorials mainly need, the popup UI for it/ deciding how it looks, I provide a base widget with slide in and out animations, and a way to edit the text per-tutorial-class, for quickly making new tutorials with the placeholder base widget.

Additionally, both for the scope of this plugin, and acknowledging that the needs for how tutorial popups should look can vary widely between projects, instead of making a fixed popup widget with customization options, I provided the option to entirely replace the base widget with the user's own widget, customized directly using Unreal's Widget Editor, as long as they implement an interface on it for triggering its start and completion animations, and overriding the text. I may also add other per-widget override options in the future, for more easily reusing one widget for multiple tutorials.

Also, should the user be using a different type of UI system in their project such as Commun UI, there are options to override functions on the tutorial monitor component, to create and show widgets how the user needs for their project.

Intro Conclusion

There are more specifics to the system for further customization and use cases, such as options for how the tutorials automatically save, and a provided tutorial trigger box, but this about covers the main ways that can be used to start making tutorials with the GGameUtils Tutorial System Lite plugin. And, if you want to know more, you can check the plugin, and its associated documentation, out on the FAB store for free! https://www.fab.com/listings/e4bc4ec0-a632-46c3-a633-4e65e5343ed3. And, thanks for giving this page a look!

Code Samples

If you'd like to check out the code, it's publicly available, and please give a look at this repository folder here:

(NOTE: The private and public folder names just refer to how they exist inside the plugin for its use in Unreal Engine, and the entire repository is public to view.)

https://github.com/RileyDurb/GGameUtils/tree/main/GGameUtils/Plugins/GGameUtilsTutorialSystem/Source/GGameUtilsTutorialSystem

P.S. For recommended files to look at:

The TutorialMonitor.h/.cpp files have the unreal actor component that holds and manages the tutorials. Link to .h Link to .cpp
The BaseTutorialConditions.h/cpp files hold the base tutorial class users can derive from using blueprints or C++, to make their own tutorials. Link to .h Link to .cpp

Page updated

Google Sites

Report abuse