Size Disparity

Introduction

In previous Unreal Engine projects I had used Blueprinting as a method of rapid prototyping and development. While blueprinting is an incridible tool, the speed and flexibility of C++ when used alongside the game developmenmt engine is undeniable. As this is the standard in Industry I wanted to take the opportunity to explore how custom C++ functionality aids within the Unreal Engines development cycle.

The project features the use of a custom built weight component & interface. These were built with modularity in mind, as such each interactable element could communicate via the weight interface rather instead of directed coupled communication.

Weight Interface & Component

Over the span of the project I had the oppurtunity to research different programming principles & paradigms. Many of which propagated that when it comes to Object-Orietned Programming, modularity is the best practise the SOLID principles being a prime example of this. This research prompted me to look at how interfaces and components can be used within Unreal Engine to create modular systems, which can be further extended by designers in Blueprints.

While I had previously used pre-made interfaces, this was my first ventrue into making my own. I found the advantages to modular communications to be fascinating, as keeping the weight interface structurally simple allowed for any actor who could interact with the interface to get or set the weight of another actor when prompted with no need for direct coupling.

This was furthered by the weight component, which focused on interacting with the players main mechanics. This allowed for the player to interact with the size-changing pill which would adjust the players size and variables. As this system was build with designer extendibility in mind, I would want to provide the player with additional mechanics when in different sizes, which could be nicely extended in C++ or Blueprints due to the structure being built for both.

Code - Weight

What was Learnt

This project gave me the opportunity to take a deep dive in the framework of Unreal Engine, and how it can be best used to bridge the gap between Programmer and Design work. Looking into UFunctions & UPropertys, and how their behaviour can be specified using MetaData tags helped me not only understand my own code, but also how systems can be extended with a whole team in mind.

Additionally this served as an opportunity to explore the benefits of using C++ within unreal engine, the flexibility, control and improved structure all serve to better any project it is implemented in. This was furthered by exploring the implemention of Design Patterns, such as the Command Design Pattern, which I had used for the character controller and weight interactions. Another pattern that would be important for this project, if it were to be extended, is Object Pooling. As an optimisation pattern it would be imperative at keeping performance needs low, especially as games expand and require more and more resuable elements.

Project Repository