The six core objectives

The exam will mainlyfocus on scripting and the use of Unity'sApplication Programming Interface(API), Animation Controller, particles, rendering, and more. The whole idea is to get you familiar with what Unity has to offer you as a programmer. Unity has categorized their exam into core sections, which is a nice way of separating the workload up for the exam.

The six core objectives are as follows:

• Programming core interactions
• Working in the art pipeline
• Developing application systems
• Programming for scene and environment design
• Optimizing performance and platforms
• Working in professional software development teams

Let's look at these in more detail.

Programming core interactions

When we load up our first blank scene in Unity, we will be controlling objects (or, as Unity likes to call them, game objects), moving, rotating, and/or expanding them. Not only can you adjust or transform these game objects, but you can also give them components to make them behave like a camera or light. Each component will have a list of properties and a camera that you can zoom in and out, change the focal length, and edit the details. Another component is "physics"—what happens if one game object collides with another? What would you want the game object to do? Will it blow up? Will it collect the other game object? Will it knock it out of the way? Unity wants you to know how to use these components and game objects. They also want you to know how you can control these objects with a control pad or keyboard controls as if they are characters in a computer game. This may already sound daunting but you don't need to be a math teacher to be successful (but it's great if you are!). What's so brilliant about Unity is that it does a lot of the hard work for you. All you need to know is what you want and how you want to use it.

To pass the exam, you need to know how to do the following:

• Implement and configure game object behavior and physics
• Implement and configure inputs and controls
• Implement and configure camera views and movement

Let's move on to the second Unity exam core objective—the art.

Working in the art pipeline

As you know, this is a programming exam, so why do we have an exam objective that refers to art? Well, as a programmer, it's highly likely that you will be manipulating game objects to do the things mentioned in the exam objectives. You might not just move something around—you may also want to change a game object's color. For example, instead of having a cargame object that's dull and flat, you may want it to be shiny and reflective with a gold tint. For this to happen, a game object typically has a material assigned to it that you can apply maps with. These maps can contain colors, marks, and dents.

All these maps and their properties will alter, change, or enhance your game object to what is known as a pipeline, which is the process of your game object becoming something more than its original form. If you want the game object's car wheels to turn around, then how can you do that? You may not have an animator to do this. You also may be asked to animate a scene's lighting in the code and not manually tweak its properties. You're not expected to be a master at animation or lighting, but Unity wants you to know the basics. It might not be the artist's job to include snow or rain in your game, and it's likely that you will have to use a particle system to create these effects. How will you change its properties to change from a light drizzle to a thunderstorm in code? If you don't know, don't worry—you will be introduced to these components and their properties soon.

To pass the exam, you also need to know how to do the following:

• Understand materials, textures, and shaders and write scripts that interact with Unity’s rendering API
• Understand lighting and write scripts that interact with Unity's lighting API
• Understand two-dimensional and three-dimensional animation and write scripts that interact with Unity's animation API
• Understand particle systems and effects and write scripts that interact with Unity's particle system API

Let's now move on to the third Unity exam core objective, where we focus on interfaces, storing data, and being aware of multiplayer functionality.

Developing application systems

I wouldn't say that this is a core objective as such; it's more of a cluster of things Unity have tied into one bundle and labeled it "core." So, let's break this down and work out what they want from us. Developing application systems is focused on how Unity communicates with the user and stores their information. This is where a User Interface (UI) needs to contain the right guidance and information; but also, from a technical point of view, it needs to be positioned correctly no matter what ratio the screen size is. UI can also be used in-game in the form of a minimap guiding the player through a maze, showing them where enemies are. UI can also be used for advertising and displaying information from a different computer server online. When information is taken from the player, how sensitive is this information? Should it be stored locally with low security? Do we need encryption? Should it be stored in a different file format online? Finally, Unity is currently getting rid of their multiplayer network system, called UNet, and replacing it with something brand-spanking new. This means we only need to be aware of Unity's network and prepare for a few general networking exam questions.

To pass the exam, you need to know how to do the following:

• Interpret scripts for application interface flow such as menu systems, UI navigation, and application settings
• Interpret scripts for user-controlled customization, such as character creators, inventories, storefronts, and in-app purchases
• Analyze scripts for user progression features, such as scoring, leveling, and in-game economies, by utilizing technologies such as Unity Analytics and PlayerPrefs
• Analyze scripts for two-dimensional overlays, such as Heads-Up Displays (HUDs), minimaps, and advertisements
• Identify scripts for saving and retrieving application and user data
• Recognize and evaluate the impact of networking and multiplayer functionality

Let's move on to the fourth Unity exam core objective, where we'll focus again on game objects.

Programming for the scene and environment design

This core exam objective sounds similar to the first core objective, where we introduced the game object; however, this time we are concentrating more on the management of the object. When is a game object made? How is it made? How do we get rid of it when we don't need it anymore? Should we destroy it? Or, do we label it as destroyed but store it elsewhere in the scene to save memory? We can also look at less common components, such as artificial intelligence, and understand what a game object would do if, for example, it's a character that knows when to patrol, chase an enemy, or hide. We will also need to know about the audio component and mixer, how we can manipulate them, and how to create echo effects. Yet again, we have a situation as with the animation and art—we don't need to be amazing at these skills, we just need to know that they exist.

To pass the exam, you need to know how to do the following:

• Determine scripts for implementing audio assets
• Identify methods for implementing game object instantiation, destruction, and management
• Determine scripts for pathfinding with the Unity navigation system

Let's move on to the fifth Unity exam core objective, which is about knowing what to do when you've broken something and how to check performance issues.

Optimizing performance and platforms

Any programmer will encounter problems, and it's sometimes helpful to know about the problem before you have to solve it. This Unity exam core objective is about tracking and fixing your own issues. Sometimes, you will need to step through your code to find a game-breaking bug, or you might want to know why a game is stuttering at a certain point when it is played. This is where you would use one of Unity's handy tools, such as the profiler, to monitor performance. You will be able to strip back the components to see whether you're dealing with a physics issue or whether your second scene is taking a long time to load, for example. Being able to solve your own problems with Unity's tools is the key point of this core objective. Other examples of issues that Unity wants you to think about is, for example, if you are going to build a virtual reality app, where would the UI be placed, if at all? Do you need to be more aware of your frames per second? These are the types of questions we will cover in the book.

To pass the exam, you need to know how to do the following:

• Evaluate errors and performance issues using tools such as the Unity profiler.
• Identify optimizations to address requirements for specific build platforms and/or hardware configurations.
• Determine common UI affordances and optimizations for XR platforms.

Let's now move onto your sixth and final Unity exam core objective, working with people.

Working in professional software development teams

Working with others in a professional environment and sharing and working with each others' code can be tricky if a decent structure isn't in place. Things such as version control can help, where each member can book their work in and book it out. Some users might work remotely, or you could all work remotely. There are different types of version control; the most typical one used is called git. Unity also has its own version that they would really like you to use. We will be covering Unity Collaborate in this chapter, which is a program that lets you book your work in, book it out, alter it, make some mistakes, and fix it all in the end.

To pass the exam, you need to know how to do the following:

• Recognize concepts associated with the uses and impacts of version control using technology such as Unity Collaborate
• Demonstrate knowledge of developer testing and its impact on the software development process, including the Unity profiler and traditional debugging and testing techniques
• Recognize techniques for structuring scripts for modularity, readability, and reusability

That's it! If you know the content of these six objective cores, you will pass. This book will cover all of these problems and issues within the project that we will be talking about later on in this chapter. How will you know whether you've successfully met your objectives? I will be throwing questions at you every few chapters to see how you are getting on. If you fail or don't do too well, then I see that as a good thing because you'll know exactly what you need to focus on and revisit before taking the exam.

Anyway, this is all to come. Next, I want to talk about design patterns. Given that we are coding, it's a good idea to talk about structuring code, following decent methods, and not creating code that can get tangled into a mess if there isn't enough planning in place.