Learn by comparison how to create a First Person Game using two scalable approaches in Unity
What you'll learn
- Learn Two Game Architectures that you can apply to your games
- Create Maintainable and Scalable Code
- How to Implement Solid Code Architecture that you can Reuse in different Projects
- How to separate logic, visual and data in your code that are less dependent of Monobehaviour class
- Basic concepts of Dependency Injection
- How to integrate GUI with Audio Mixer, user interactions and flow control

Requirements
- Advanced knowledge in Unity Game Engine

Description
Scalability is one of the biggest problems in Unity projects. The unimaginable amount of freedom and lack of clear guidelines can lead us to complex systems interacting in such a way that no human brain can handle it. In a project with 10,000+ lines of code, every single change can be a high risk of breaking another component, with endless edge cases emerging with every new feature.

Especially if you are a small studio or a solo developer, this course can be the key to avoiding this problem and gaining confidence in building complex, solid Unity projects. In this course, we will develop a simple survival game using two different scalable architectures.

Introduction:

Here we will dive deeper into architecture problems, explore the proposed solutions in this course, and understand in which scenarios each one is better than the other. What is flow control? What is glue? These concepts are presented here.

Creating and Understanding the Project:

We will quickly prepare everything we need to dive into the code. We will create the project, add visual assets, and prepare the scene.

Handling Gameplay Features - Movement:

At this point, we will have our first contact with both architectures. We will discuss and build together a First Person Controller, handling movement, reading inputs, splitting the problem into small pieces, and solving each piece. We will also learn how to separate data from logic.

Handling Gameplay Features - Health:

Here we are going to discuss and implement the Health System. Why? Because it is a feature that involves triggers and interactions between the Player and the environment, and we'll see how differently these interactions are handled between the different architectures.

Handling Gameplay Features - Day and Night Cycle:

Time, Skybox, and Fog are different components that we will combine into a system that will work as the Day and Night Cycle of the game. This is where we will find a few similarities between Glue and UD, explore the idea of dependency injection, and much more.

Handling GUI:

Finally, here you will understand the full power of the UD architecture. We will build a simple Pause and Settings Menu that will enable the player to control the Mixer (Volume) of the game. How to handle user interactions? How to separate view from logic? We are going to dive into these questions at the end.

Do you prefer flexibility and speed? Or do you want full control of your project?

Get this course, learn them both, and decide.

Who this course is for:
- Game Developers
More Info