Objective Management System

RAIN -
Average Rating:  
X Rating Failed

High-level approach to the management of objectives completion.

  • Supported Platforms
  • Supported Engine Versions
    4.16-4.18

Description


The definition of an Objective is defined by the User, but is generally an abstract or physical object that Player has to complete for a reward. The Objective Management System(OMS) is an effort to make objective management autonomous and easy to set up in an abstract and object-oriented manner. The OMS is designed to take in Objectives from User as parameters, and then the User is only required to set up logic (rules) of what cause and what happens at completion(events).

In other words, the User connect the dots: by binding an object interaction to completion and doesn't need to be concerned about setting variables to keep track of Objective completion (Which objectives is completed? How many times? Is it meeting the condition of completion for this very specific gameplay?).

The User tell the OMS what are the objectives, and then bind any (Player) interaction to those objectives to completion using OMS functionnalities.

OMS was designed to fit a wide variety of completion setup, and thus OMS's tools takes in parameters:

For example, User can propose the Player several objectives and only be concerned that the Player complete the first 5 before allowing the Player to move towards another section of the game using the 'Ntime' parameter. You can set cross-level waypoints or level-bound collectibles. Perhaps you want the Objectives to be infinitely completable. Perhaps you want Objectives to be completable only sequentially, or not... Et cetera.


Target and usage:

Intermediate users (Level - Gameplay Designers). OMS is aiming at OpenWorld SandBox games, but can be used for "smaller" games. I expect C++ Users to use this source code as time-saver / template to write upon, even though that might be conflicting with new code addition from my part to this project

Technical Details


Features:

  • OMS's go-to is the Gatherer object(AActor) and it's derivations. It can gather physical objectives and has a built-in manager inside. Gatherers comes with Delegates/EventDispatchers to enable other objects to observe the processing of Objectives and apply game rules.
  • As it is a Beta release the features "wishlist" are yet to be thoroughly tested and (re-)implemented/re-shaped. Anticipated modifications regards trimming and splitting current code in a more versatile suite of objects enabling an easier composition of objects (as components), and adding support for abstract objectives.
  • Interaction with OMS is minimal.
  • Saving completion of objectives can be reduced down to one parameter.

Code Modules:

  • Gatherers (Runtime)
  • BaseComponents (Runtime)

Number of C++ Classes: 3 AActors-derived classes. 1 Interface. Four UActorComponent-derived classes. Some other enum classes used by those precedently listed classes.

Network Replicated: No(t yet)

Supported Development Platforms: Win64.

Supported Target Build Platforms: Win64.

Resources (Documentation, Example Project):

https://www.dropbox.com/sh/aqkfqz6ipzq4y2g/AAAuNIcXyeB771U8YfLZ7Mfha?dl=0

Videos:

https://www.dropbox.com/sh/cq54fgik9vruebo/AACTczbKBSwjdr25JbY3vMbLa?dl=0

Important/Additional Notes:

BETA.

Developed for and from a Win64 architecture, so I can't claim it works for other platforms other than Win64. The uplugin was for this reason whitelisted to Win64 platforms only. However the source code is written in a standard Unreal-assisted C++ and doesn't have much platform specific code (only using a MS compiler's __FUNCTION__ wrapped in necessary ifdef)

Comments

!

Previous Next
  • Edit
  • Preview
  • Help
Enter
Login to comment
X Report this Comment
Report
X Attention


close
X Edit this Comment
  • Edit
  • Preview
  • Help
Update
X Remove this Comment

Are you sure you want to remove this comment?

Remove
X Attention