Unity c# scripting tutorial for absolute beginners

A Beginner's Odyssey: Your First Unity C# Scripting Tutorial

Welcome, aspiring game developer! You've likely spent countless hours exploring digital worlds, marveling at the intricate mechanics and captivating stories. Now, a new adventure awaits: creating those worlds yourself. The idea of writing code can seem like a monumental barrier, a cryptic language reserved for wizards of the tech world. But what if I told you that with the right guide, you could write your first lines of code today and bring a simple game object to life?

This is your starting point. This comprehensive tutorial is designed for the absolute beginner—no prior coding experience required. We will be using Unity, one of the most popular and powerful game engines in the world, and its primary scripting language, C#.[1] Scripting is the soul of any Unity game; it's the set of instructions that dictates how game objects behave, respond to player input, and interact with each other.[1][2]

By the end of this guide, you will understand the fundamental concepts of C# scripting in Unity. You'll learn how to create scripts, understand variables, move objects, and even respond to player keyboard input. Prepare to lift the curtain and see the magic behind the games you love.

Chapter 1: Setting Up Your Developer's Workshop

Before we can write code, we need to prepare our environment. This is the foundational step, like an artist setting up their canvas and brushes.

Prerequisites: The Essential Tools

Unity Hub & Editor: Your journey begins at the official Unity website. Download and install the Unity Hub. This is a management tool that allows you to install different versions of the Unity Editor and manage your projects. Once the Hub is installed, use it to install a recent, stable version of the Unity Editor (any version from 2022 LTS or newer is a great choice).

Visual Studio Community: During the Unity Editor installation, the Hub will prompt you to add modules. Ensure that "Game development with Unity" is selected.[3] This package includes Visual Studio Community, a powerful Integrated Development Environment (IDE) where we will write our C# code. Unity and Visual Studio are designed to work together seamlessly.

Your First Unity Project

With your tools installed, open Unity Hub and click "New Project." You'll see a list of templates. For now, select the 3D Core template, give your project a name (like "MyFirstGame"), choose a location to save it, and click "Create Project."

After a few moments, the Unity Editor will open. You might be greeted by a number of windows, which can be overwhelming. Let's briefly demystify the most important ones:

Scene View: Your visual canvas. This is where you'll place and manipulate the objects in your game world.

Hierarchy: A list of all the objects (called GameObjects) currently in your Scene.

Project Window: Your file explorer. All your project assets—scripts, models, textures, audio—live here.

Inspector: When you select a GameObject in the Hierarchy, its properties and components are displayed here.

Console: Your debugging window. When things go wrong, or when you want your code to send you a message, it will appear here.

A caption describing the basic Unity layout.

Creating and Attaching Your First Script

In Unity, everything in your scene is a GameObject. A GameObject can be a character, a light, a camera, or even an invisible object that just holds logic. To give a GameObject behavior, we attach Components to it. A script is simply a custom component you create.

Let's create an object to control.

In the Hierarchy window, right-click, select 3D Object, and then click Cube. A white cube will appear in your Scene View.

Now, let's create the script. In the Project window, right-click, go to Create, and select C# Script.

This is a critical step: Name your script immediately. Let's call it PlayerController. Press Enter. Do not use spaces or special characters in script names. It's a common beginner mistake to rename the file later, which can cause errors. If you make a mistake, it's often easier to delete the script and create a new one with the correct name.[3]

Now you have a GameObject (the Cube) and a script (PlayerController). To make them work together, you must attach the script to the GameObject.

Click and drag your PlayerController script from the Project window directly onto the "Cube" in the Hierarchy window.

To verify it worked, select the Cube in the Hierarchy and look at the Inspector window. You will see your "Player Controller (Script)" component added at the bottom. You have successfully given your cube a "brain," which we will now program.

Chapter 2: A Look Under the Hood - Anatomy of a C# Script

Double-click your PlayerController script in the Project window. This will launch Visual Studio and open your new script file. You'll see some code has already been generated for you. Let's break it down piece by piece.

using UnityEngine;: This line is an instruction to use Unity's built-in code library, known as the Application Programming Interface (API).[4][5][6] Think of it as telling your script, "I want to use all the special commands and tools that Unity provides."[4][7] This line is essential for almost every script you'll write.

public class PlayerController : MonoBehaviour: This is the main container for our script.

public class PlayerController: This declares a new class named PlayerController. A class is a blueprint for creating objects. The name here must exactly match your script file's name.

: MonoBehaviour: This is the most important part. By "inheriting" from MonoBehaviour, we are giving our script special properties. It allows the script to be attached to GameObjects and gives us access to Unity's event functions, like Start and Update.[4][8]

void Start(): This is a special function that Unity calls automatically.[1] Any code placed inside the curly braces {} of the Start function will run exactly once when the game begins, just after the object is loaded into the scene.[9] This is perfect for setup tasks.

void Update(): This is another special function Unity calls automatically. Unlike Start, the code inside Update runs every single frame.[1] If your game is running at 60 frames per second, the Update function will be called 60 times per second. This is where the core game logic, like checking for player input or moving characters, will go.

Writing Your First Line of Code

The best way to learn is by doing. Let's write a simple command to prove our script is working. We'll use Debug.Log(), a command that prints a message to Unity's Console window. It's an invaluable tool for debugging.

Inside the Start function, type the following line:

The Power of public

You might have noticed the word public before each variable declaration. This is an access modifier, and it's incredibly powerful in Unity. When you declare a variable as public, it exposes it in the Unity Inspector.

Save your script and return to the Unity Editor. Select your Cube and look at the Inspector. You will now see your variables listed in the Player Controller component, with their values ready to be edited!

This is a cornerstone of Unity's design. It allows you to tweak game values—like player speed or health—without ever having to open your code editor. This empowers rapid iteration and allows non-programmers to balance and design the game.

Chapter 4: Bringing Your World to Life with Functions and Logic

Now that we have variables, let's use them to create movement. Our goal is to move the cube using code.

Understanding the Transform Component

Every single GameObject in Unity has a Transform component. [6]The Transform stores the GameObject's position, rotation, and scale in the 3D world. We can access and modify this component directly from our script.

Creating Movement in Update

Since we want our cube to be able to move continuously, the logic should go inside the Update function, which runs every frame. We'll use the transform.Translate() function, which moves the object by a certain amount.

Add the following line inside your Update function:

Vector3.right is a shorthand provided by Unity that represents movement of 1 unit to the right along the X-axis. Save the script and press Play in Unity.

The cube shoots off to the right at an incredible speed! Why? Because we are telling it to move one full unit every single frame. On a fast computer, this happens hundreds of times per second.

Frame Rate Independence with Time.deltaTime

To achieve smooth, consistent movement across all devices, regardless of their frame rate, we must use Time.deltaTime. This magical value represents the amount of time that has passed since the last frame was rendered.

By multiplying our movement by Time.deltaTime, we change our logic from "move X units per frame" to "move X units per second." Let's modify our code. We'll also incorporate our moveSpeed variable.

Now save and play the game. The cube moves to the right at a controlled, consistent speed of 5 units per second. Try changing the moveSpeed value in the Inspector while the game is running to see the effect instantly!

Chapter 5: Player Interaction - The Input System

A game isn't much fun if you can't control it. Let's hook up our movement logic to the player's keyboard input. Unity has a robust Input system that makes this easy. We'll use Input.GetAxis().

Input.GetAxis("Horizontal") checks for input from the 'A' and 'D' keys or the left and right arrow keys. It returns a value between -1 (for left) and 1 (for right). Input.GetAxis("Vertical") does the same for the 'W' and 'S' keys or the up and down arrow keys.

Let's put this into practice.

Here's what we're doing:

We read the horizontal and vertical input each frame and store it in float variables.

We create a Vector3, which is an object that holds X, Y, and Z coordinates, to represent our desired direction. We use our input values for X and Z (since in a 3D world, forward/backward is typically along the Z-axis).

We then use this moveDirection vector to translate our object, again moderated by our moveSpeed and Time.deltaTime.

Save your script and press Play. You can now move your cube around the scene using the WASD or arrow keys!

Chapter 6: Making Decisions - Conditional Logic

Programming is all about making decisions. The most common way to do this is with an if statement. An if statement checks if a certain condition is true, and if it is, executes a block of code.

Let's add a simple action: if the player presses the Space bar, we'll print a message to the console. Unity's Input.GetKeyDown() function is perfect for this, as it returns true only on the single frame the key is first pressed down.

Now when you run the game and press the Space bar, your "Jump!" message will appear in the console. This simple conditional logic is the foundation for everything from shooting a weapon to opening a door or checking if a player's health has reached zero.

Chapter 7: The MonoBehaviour Lifecycle and Physics

Unity calls many event functions in a predictable order, known as the script lifecycle. [8][10]We've used Start() and Update(), but there are others.

Awake(): This function is called even before Start(). [9][11]It's primarily used for setting up references between scripts and components.

FixedUpdate(): This is called at a fixed, consistent interval, independent of the frame rate. It's the best place for any code involving physics, like applying forces, to ensure consistent results.
[12]* OnCollisionEnter(Collision other): This function is called automatically whenever this GameObject's collider bumps into another. This is the key to detecting interactions. For this to work, our object needs a Rigidbody component, which tells Unity's physics engine to take control of it.

Let's add a Rigidbody to our Cube. Select the Cube, go to the Inspector, click "Add Component," and search for "Rigidbody." Add it. Now your cube is subject to gravity.

Create a new 3D Object, a Plane, to act as a floor. Scale it up so it's large enough to drive on. Now let's detect when our cube lands on the plane.

Add this entire function to your script. The Collision other parameter contains information about the object we hit. We can access its name via other.gameObject.name.

Press Play. Your cube will fall onto the plane, and you'll see a message in the console saying "Collided with: Plane". You have just detected your first physical interaction!

Conclusion: Your Adventure Has Just Begun

Take a moment to look back. You started with an empty project and a head full of dreams. Now, you have a controllable object that responds to your commands and interacts with its environment. You have created a script, declared variables, understood the core game loop, handled player input, and made logical decisions. You are no longer just a player; you are a programmer and a game developer.

This is merely the first step on an incredibly rewarding journey. From here, you can explore countless new concepts:

Instantiating and destroying GameObjects (like spawning enemies or projectiles).

Using GetComponent<T>() to make scripts talk to each other.

Building a User Interface (UI) to display health and score.

Working with animations, audio, and visual effects.

The most important thing you can do now is practice and experiment. Take the scripts we've written and modify them. Try adding a "sprint" button that changes the moveSpeed. Make the cube change color when it hits the ground. The path to mastery is paved with curiosity and countless small projects. Welcome to the world of game creation.

Search This Blog

TheGameDev