Unleashing the Power of C# and Visual Scripting

Unity has a lot of great built-in tools to solve the most common problems in game development, such as the ones we have seen so far. Even two games of the same genre have their own little differences that make each game unique, and Unity cannot foresee that, so that’s why we have scripting. In this chapter, we will introduce the two main Unity scripting options: C# and visual scripting. We will discuss their pros and cons and the base knowledge required to start creating gameplay with them. From now on, we will see how to achieve all our scripts using both options.

In this chapter, we will examine the following topics:

• Introducing scripting
• Creating scripts
• Using events and instructions
• Common beginner C# script errors

We are going to create our own Unity components, learning the basic structure of a script and the way that we can execute actions and expose properties to be configured...

Introducing scripting

Through coding, we can extend Unity’s capabilities in several ways to achieve the exact behavior we need, all through a well-known programming language—C#. However, aside from C#, Unity also has visual scripting, a way to generate code through a node graph tool.

This means you can create scripts without writing code but by dragging nodes, boxes that represent actions that can be chained:

Figure 5.1: Example of a visual scripting graph

While essentially both ways can achieve the same result, we can use them for different things. Usually, the core logic of a game is written in C# due to it usually being huge and very performance-sensitive. However, sometimes using visual scripts instead allows non-programmer team members, like artists or game designers, to have more freedom to edit minor changes in the game, especially regarding balancing or visual effects.

Another example would be game designers prototyping ideas through visual...

Creating scripts

The first step to creating behavior is to create script assets; these are files that will contain the logic behind the behavior of our components. Both C# and visual scripting have their own type of asset to achieve that, so let’s explore how to do that in both tools.

Having some programming knowledge is required in this book. However, in this first section, we are going to discuss a basic script structure to make sure you have a strong foundation to follow when we code the behaviors of our game in the following chapters. Even if you are familiar with C#, try not to skip this section because we will cover Unity-specific structures of code.

In this section, we will examine the following script creation concepts:

• Initial setup
• Creating a C# script
• Adding fields
• Creating a visual script graph

We are going to create our first script, which will serve to create our component, discussing the tools needed to do so and...

Using events and instructions

Now that we have a script, we are ready to do something with it. We won’t implement anything useful in this chapter, but we will settle the base concepts to add interesting behavior to the scripts we are going to create in the next chapters.

In this section, we are going to cover the following concepts:

• Events and instructions in C#
• Events and instructions in visual scripting
• Using fields in instructions

We are going to explore the Unity Event System, which will allow us to respond to different situations by executing instructions. These instructions will also be affected by the value of the editor. Finally, we are going to discuss common scripting errors and how to solve them. Let’s start by introducing the concept of UnityEvents in C#.

Events and instructions in C#

Unity allows us to create behavior in a cause-effect fashion, which is usually called an event system. An event is a situation that...

Common beginner C# script errors

Visual scripting scripts are prepared in a way in which you make fewer errors, not allowing you to write incorrect syntax like C# script does. If you are an experienced programmer, I bet you are quite familiar with them, but let’s recap the common errors that will make you lose lots of time when you start out with C# scripting. Most of them are caused by not copying the shown code exactly. If you have an error in the code, Unity will show a red message in the console and won’t allow you to run the game, even if you are not using the script. So never leave anything unfinished.

Let’s start with a classic error, a missing semicolon, which has resulted in many programmer memes and jokes. All fields and most instructions inside functions (such as print), when called, need to have a semicolon at the end. If you don’t add a semicolon, Unity will show an error, such as the one in the screenshot in Figure 5.39, in the console...

Summary

In this chapter, we explored the basic concepts that you will use while creating scripts. We discussed the concept of a script’s assets and how the C# ones must inherit from MonoBehaviour to be accepted by Unity to create our own scripts. We also saw how to mix events and instructions to add behavior to an object and how to use fields in instructions to customize what they do. All of this was done using both C# and visual scripting.

We just explored the basics of scripting to ensure that everyone is on the same page. However, from now on, we will assume that you have basic coding experience in some programming language, and you know how to use structures such as if, for, array, and so on. If not, you can still read through this book and try to complement the areas you don’t understand with a C# introduction book, as you need.

In the next chapter, we are going to start seeing how we can use what we have learned to create movement and spawning scripts.

...