7.18. Unity scripting with C# - Basics: Creating custom scripts in Unity

In the dynamic world of game development, Unity stands out as a versatile and powerful engine that empowers developers to create captivating experiences across multiple platforms. One of Unity's greatest strengths is its ability to integrate seamlessly with C#, a robust programming language that allows for the creation of custom scripts to enhance and control game functionality. In this section, we delve into the basics of Unity scripting with C#, guiding you through the process of creating custom scripts that breathe life into your game projects.

Unity's scripting environment is built on Mono, an open-source implementation of the .NET Framework, which means you can harness the full power of C# to develop game logic, control behaviors, and interact with Unity's API. Whether you're a seasoned programmer or a newcomer to game development, understanding the fundamentals of scripting in Unity is essential for bringing your creative visions to life.

Getting Started with C# in Unity

Before diving into scripting, it's important to ensure that you have a solid understanding of the Unity interface and how to navigate it. Unity's editor is the hub where you design your game scenes, import assets, and manage your project files. Once you're comfortable with the interface, you can begin creating scripts to add interactivity and functionality to your game objects.

To create a new script in Unity, follow these steps:

1. Open Unity and navigate to the Project window.
2. Right-click in the Assets folder, then select Create > C# Script.
3. Give your script a meaningful name. It's a good practice to name scripts based on the functionality they provide, e.g., PlayerController or EnemyAI.
4. Double-click the newly created script to open it in your preferred code editor, such as Visual Studio or Visual Studio Code.

When you open a new script, you'll notice a basic structure already in place:

using UnityEngine;

public class ScriptName : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

This script template includes two important methods: Start() and Update(). These methods are part of Unity's lifecycle events, which are called automatically at specific points during the execution of your game.

The Start() Method

The Start() method is called once before the first frame update. It's typically used to initialize variables, set up game objects, or perform any setup logic that needs to occur before the game starts running. For example, you might use the Start() method to set initial health values for a player character or to position objects in the scene.

The Update() Method

The Update() method is called once per frame, making it ideal for implementing logic that needs to be checked or updated continuously. This is where you might handle player input, update the position of a game object, or check for certain conditions in the game. Because Update() is called every frame, it's important to keep the logic efficient to ensure smooth gameplay.

Understanding MonoBehaviour

In Unity, most scripts derive from a class called MonoBehaviour. This base class provides access to Unity's lifecycle methods and other essential features, such as coroutines and the ability to interact with game objects. By inheriting from MonoBehaviour, your scripts become components that can be attached to game objects in the Unity editor.

To attach a script to a game object, simply drag the script from the Project window onto the desired game object in the Hierarchy window. Alternatively, you can select the game object, click the Add Component button in the Inspector window, and search for the script by name.

Variables and Data Types

In C#, variables are used to store data that can be accessed and manipulated by your scripts. Unity supports a variety of data types, including integers, floats, strings, and booleans. When declaring a variable, you specify its type and name:

public int playerHealth = 100;
private float speed = 5.0f;

In the example above, playerHealth is a public integer variable initialized to 100, while speed is a private float variable set to 5.0. The access modifier (public or private) determines the visibility of the variable within the script and other scripts. Public variables are accessible from other scripts and are displayed in the Unity Inspector, allowing you to modify their values without changing the code.

Working with Unity's API

Unity provides a comprehensive API that allows you to interact with game objects, handle input, manipulate physics, and more. Understanding how to use this API is crucial for effective scripting. Here are some common tasks you might perform using Unity's API:

Transforming Game Objects

Every game object in Unity has a Transform component that defines its position, rotation, and scale in the scene. You can access and modify these properties through your scripts:

transform.position = new Vector3(0, 1, 0);
transform.Rotate(Vector3.up * Time.deltaTime * 90);

In this example, the position property of the Transform component is set to a new Vector3 with coordinates (0, 1, 0). The Rotate method is used to rotate the object around the Y-axis over time.

Handling Input

Unity's Input class allows you to detect user input from various devices, such as keyboards, mice, and game controllers. You can use this class to check for specific key presses or mouse actions:

if (Input.GetKeyDown(KeyCode.Space))
{
    Debug.Log("Space key was pressed.");
}

In this example, the script checks if the space key was pressed during the current frame and logs a message to the console if it was.

Using Coroutines

Coroutines are a powerful feature in Unity that allow you to execute code over multiple frames. This is useful for tasks like waiting for a certain amount of time before executing an action:

IEnumerator ExampleCoroutine()
{
    Debug.Log("Coroutine started.");
    yield return new WaitForSeconds(2);
    Debug.Log("Two seconds have passed.");
}

To start a coroutine, use the StartCoroutine method:

StartCoroutine(ExampleCoroutine());

Debugging and Testing

Debugging is an essential part of the development process, and Unity provides several tools to help you identify and fix issues in your scripts. The Debug class offers methods for logging messages to the console, which can be useful for tracking variable values and program flow:

Debug.Log("This is a log message.");
Debug.LogWarning("This is a warning message.");
Debug.LogError("This is an error message.");

Additionally, Unity's Play Mode allows you to test your game in real-time within the editor. While in Play Mode, you can pause the game, step through frames, and inspect variables to better understand how your scripts are behaving.

Conclusion

Creating custom scripts in Unity with C# is a fundamental skill for any aspiring game developer. By mastering the basics of Unity scripting, you can unlock the full potential of the engine and bring your game ideas to life. From handling player input to manipulating game objects and implementing complex behaviors, C# scripting in Unity provides the flexibility and power needed to create engaging and interactive experiences. As you continue to explore Unity and its scripting capabilities, you'll discover new ways to push the boundaries of what's possible in your game projects.