Putting the building blocks together

With the building blocks squared away, it's time to do a little Unity-specific housekeeping before wrapping up this chapter. Specifically, we need to know more about how Unity handles C# scripts attached to GameObjects. For this example, we'll keep using our LearningCurve script and Main Camera GameObject.

Scripts become components

All GameObject components are scripts, whether you or the good people at Unity wrote them. Unity-specific components such as Transform, and their respective scripts, just aren't supposed to be edited by us.

The moment a script that you have created is dropped onto a GameObject, it becomes another component of that object, which is why it appears in the Inspector panel. To Unity, it walks, talks, and acts like any other component, complete with public variables underneath the component that can be changed at any time. Even though we aren't supposed to edit the components provided by Unity, we can still access their properties and methods, making them powerful development tools.

Unity also makes some automatic readability adjustments when a script becomes a component. You might have noticed that when we added LearningCurve to Main Camera, Unity displayed it as Learning Curve, with currentAge changing to Current Age. 

Part of a previous Time for action section already had you update a variable in the Inspector panel, but it's important to touch on how this works in more detail. There are two situations in which you can modify a property value:

• In Play mode
• In development mode

Changes made in Play mode take effect immediately in real-time, which is great for testing and fine-tuning gameplay. However, it's important to note that any changes made while in Play mode will be lost when you stop the game and return to development mode. 

When you're in development mode, any changes that you make to the variables will be saved by Unity. This means that if you were to quit Unity and then restart it, the changes would be retained.

The changes that you make to values in the Inspector panel do not modify your script, but they will override any values you had assigned in your script when in Play mode.

If you need to undo any changes made in the Inspector panel, you can reset the script to its default (sometimes called initial) values. Click on the three vertical dots icon to the right of any component, and then select Reset, as shown in the following screenshot:

This should give you some peace of mind – if your variables get out of hand, there's always the hard reset. 

A helping hand from MonoBehavior

Since C# scripts are classes, how does Unity know to make some scripts components and not others? The short answer is that LearningCurve (and any script created in Unity) inherits from MonoBehavior (another class). This tells Unity that the C# class can be transformed into a component.

The topic of class inheritance is a bit advanced for this point of your programming journey; think of it as the MonoBehaviour class lending a few of its variables and methods to LearningCurve. Chapter 5, Working with Classes, Struct, and OOP, will cover class inheritance in practical detail.

The Start() and Update() methods that we've used belong to MonoBehavior, which Unity runs automatically on any script attached to a GameObject. The Start() method runs once when the scene starts playing, while the Update() method runs once per frame (depending on the frame rate of your machine). 

Now that you're familiarity with Unity's documentation has gotten a nice bump, I've put together a short optional challenge for you to tackle!

Hero's trial – MonoBehavior in the Scripting API

Now it's time for you to get comfortable using the Unity documentation on your own, and what better way than to look up some of the common MonoBehavior methods:

• Try searching for the Start() and Update() methods in the Scripting API to gain a better understanding of what they do in Unity, and when. 
• If you're feeling brave, go the extra step and have a look at the MonoBehavior class in the manual for a more detailed explanation.

Before jumping into our C# programming adventure too deeply, we need to address one final, crucial building block – communication between classes.