Wow! We finally made it. Thank you very much for making it through the book. I have nothing left to teach you within the scope of Unreal Engine By Example! We have covered so much in our journey thus far. From making a Hello Sphere using only the editor, to creating missile launching boss AIs and networked first person characters! We have covered a lot in this book, but I thought it would be a good idea to summarize some of the core learning concepts we covered.
We are now very familiar with the multiple editors of UE4, each following a fairly similar structure. We know to look at the Details panel when we wish to edit or inspect specific elements of a selected object. We know we can construct our objects via the viewport and viewport widgets. We have also learned to expose various properties of our own objects so we may tweak them via the numerous editors found within the engine. The most important thing we learned, however, is that the editor will be the window through which game designers and artists view your work. As a programmer, one of the best things you can bring to a development team is a quality of life usability for the objects and processes you create.
We have learnt about using BSP brushes to approximate level geometry and how to convert our brushes into a consolidated static mesh. We have also dabbled with placing in-game markers in the form of scene actors. Then using those markers as positional references from code to assist with our obstacle-spawning in Bounty Dash!
Blueprints was the main focus for the first third or so of this book, and, despite not featuring very much in the later chapters, is still a very powerful tool that can be leveraged by developers to create quick and effective prototypes. We learnt how to create our own blueprints from objects that already exist in the editor as well as from scratch. We have learnt how to use the context-sensitive search to find various blueprint nodes, and we also learnt about Blueprint functions, macros and delegates!
One of the more important things we learnt is that blueprints and C++ code can work together very well via UPROPERTY and UFUNCITON specifiers. This became particularly useful when we began to work with Unreal Engine's AI systems that require a nice merger of in-editor work and C++.
The speed at which we were able to create Barrel Hopper is a testament to how robust blueprint is as a development tool. I would strongly encourage using blueprint as your go-to prototyping tool going forward (if you are not using C++ that is!).
We briefly looked at the animation pipeline for Unreal. I wish we had time to cover all of the facets of unreal in great detail; you never know maybe it will be in the next book. We did cover the basics though: We have learnt how to get our characters to articulate and move within the game world via animation blueprints and animation state machines! We explored the uses of skeletons and sockets for binding external assets like guns or equipment to specific bones so they will move and update with the character. We even covered how to play animations from C++!
One of the most powerful things we covered in this book was the use of C++ with UE4. As the engine is written in C++, it is the primary tool for creating content that works seamlessly and easily with the UE4 backend. We have learnt how to inherit from and expand the UE4 base objects like AActor and ACharacter to create our own custom characters and actors that still use all of Unreal Engine's underlying systems. We have learnt how to use the reflection system UE4 has provided with the UBT and UHT via Macros like UPROPERTERY, UFUCNITON and UCLASS. We have learnt how to communicate between our project's underlying code and the editor via macro specifiers.
Using C++ outside of UEmay feel strange now that we have had delegates and a robust template library at our fingertips for so long. Learning how to leverage these systems provided with UE has been a fantastic addition to your toolset as a developer. Hopefully going forward you will defer to using C++ in your UE projects.
The Artificial Intelligence system in Unreal Engine is robust and deep; it provides us with a great template upon which we can build elaborate and complicated AI. During this book we learnt how to leverage this template to create a boss AI that used both editor based AI assets and C++ services. We learnt how to create custom nav meshes for our large floating boss. We learnt about UE4s behavior tree system, creating our own AI tree and using decorators to dictate logic flow. We created blueprint and C++ tasks that can be executed to have the AI perform some custom functionality. We combined all of this knowledge to create a boss that changes through three different states of behavior and fires missiles!
Unreal boasts a very robust and feature-rich renderer. Again this is a whole other ball game when it comes to information we did not cover. I would strongly suggest that you look up more resources on the Unreal Engine rendering and material layers if you wish to continue developing your rendering skills with Unreal Engine. Having said that, we learnt how to leverage this through Unreal Engine materials! We have learnt about texture UV's and normal maps to create minute details and bumps on a surface. We have learnt about the main material node and all of the different input channels and how to leverage them to create cool effects like emissive glows! We have also just learnt how to profile our graphics scene so we can get a rough idea of how much pain we are putting our gpus through!
The last feature we learnt about was that of the Unreal Engine networking layer! Congratulations on creating your very own networked first person shooter. We learnt about networking protocols, like peer 2 peer or client server. We learnt about networking roles and how we can change our logic so that it functions with server authority in mind. We leveraged this networking role knowledge to then implement our own RPCs that invoked specific functionality on either the client or server. We learnt how to replicate information between networked objects via the replicated specifier and GetLifetimeReplicatedProps().
The most important thing we learnt about networking is how to construct our backend game code to accommodate for the various networking roles. If you wish to continue to learn about and use Unreal Engine as a networking platform I would strongly suggest looking into the networking interpolation functionality included in the UMovementComponent. It is there that you will begin to find out how UE4 deals with lag in games!