All content in this course uses:

Random obstacle size, direction, and speed

In this tutorial, you’ll write your first Unity script to control how each obstacle behaves. By assigning random properties — like size, direction, and speed — you’ll make your game world feel unpredictable and alive. Along the way, you’ll learn key C# scripting concepts, how to edit prefabs directly, and how to test and tune behaviors in real time.

In this tutorial, you’ll write a simple script that gives each obstacle a random size, direction, and speed. You’ll learn the basics of Unity scripting — including how to use variables, random number generation, vector math, and more — to make your game world feel dynamic and unpredictable.

Overview

If you’ve never done any programming before, here’s something important to keep in mind: coding can feel confusing at first — and that’s completely normal. It might feel like everything is happening in another language. That’s because, in many ways, it is. Programming is a new way of thinking, and it takes time to get used to the words, structure, and logic behind it.

Don’t expect to understand everything right away. Instead, think of these tutorials as an introduction to key ideas, or like planting a seed. The goal isn’t to memorize or totally understand it immediately. Instead, the goal is to start recognizing patterns that will make more sense to you each time you see them.

Just like learning to read or learning the controls in a new game, learning to code takes practice and repetition. You’re not falling behind, you’re just beginning.

 A note about learning to code

So far, you’ve added built-in components to your GameObjects — like the 

components — which were created by Unity. These components gave your GameObbjects physics and collision behavior without needing to write any code.

Now, you’re going to create your own component: a custom script that controls how each obstacle behaves when the game starts. A 

 is like a set of instructions you give to a GameObject — telling it how to behave when the game runs. The script you’re going to create will change the size, direction, speed, and spin of each obstacle.

, a popular programming language used for games, apps, and more. 

You’ll create the script, name it, and attach it to your 

prefab, so every copy of that prefab uses the same behavior.

 MonoBehaviour is the base class that all Unity scripts inherit from — it gives your script access to Unity’s built-in features like physics and lifecycle methods. Don’t worry about fully understanding it yet — you’ll get more comfortable with it over time.

 Unity requires that the script name exactly matches the class name inside it. If the names don’t match, you’ll get an error. If you make a mistake on its spelling, delete the script and create it again with the correct name.

, then search for and add your newly-created 

 GameObjects in the scene, those instances of the prefab will now also have the 

Any changes you make in the script will automatically apply to all prefab instances.


You’ve now created your first custom component — one you’ll fully control with your own code.

Create and attach a new script

Before you start writing code, it’s helpful to understand the structure of a basic Unity script. When you double-click your script file, Unity will open it in your code editor (like Visual Studio or VS Code). 

The default script comes with two important methods: 

, and Unity calls them automatically at specific times during gameplay.

 If nothing happens or you see an error, you might need to install or set up a code editor. Follow 

these instructions on how to set up your IDE integration with Unity

check out the Unity manual page on Visual Studio C# integration

At the top of the script, you’ll see the 

 — these tell the script what code libraries the script can reference.

 definition that matches your script’s name: 

 runs once, when the GameObject is first created in the scene.

 runs once per frame — it’s used to check things like input or movement.


 Your script might look a bit different depending on your version of Unity or which IDE you're using — and that’s okay!

You don’t need to fully understand what each part of the code does yet. For now, just focus on recognizing the basic structure — you’ll add your own code inside these methods soon.

Understand the script structure

Let’s write your first real line of code. You’ll use the 

 method to change the scale of the obstacle when the game begins. You’ll set the obstacle’s size using a piece of data called a 

 — which holds three values: X, Y, and Z.

You’ll set the scale by accessing the GameObject’s 

 component, the component Unity uses to store an object’s position, rotation, and scale. In your code, setting the 

 affects how big or small the object appears in the scene.

Rather than copying and pasting the code below, try typing it out yourself. As you type, you might notice that your code editor suggests autocomplete options — including method names, definitions, and parameters. This is a feature of most modern editors (like Visual Studio or VS Code), and it makes coding faster and less error-prone.

If you don’t see suggestions as you type — and you’re using a macOS — you might need to configure your editor to properly support Unity and C#. Once it’s working, autocomplete will save you a lot of time.

Inside the opening and closing curly braces 

 value is required, even though it doesn’t affect 2D visuals.

 sign here doesn’t mean "is equal to" like in math — it means you’re setting the variable on the left to be equal to the value on the right.

Don’t close your code editor — you’ll be coming back to it.


Switch back to the Unity Editor and select the 

button. You’ll see your obstacles appear at twice the scale they were originally.

Exit Play mode when you’re done testing.


You’ve just written your first line of gameplay code — and seen how scripting directly affects your prefab. Next, you’ll take this further by giving each obstacle a random size instead of a fixed one.

Change the size using a fixed value

 function to give every obstacle a random scale when the game starts.

 — a piece of data that can change. In this case, you'll store a random number in a variable and then use it to scale the obstacle.

1.  Declare a new variable to store a random size:

 is short for “floating point number”, which means the variable can store a number with decimals.

 picks a value between the two numbers you give it (including the minimum, excluding the maximum).
You can name your variable anything, but 

 mean that the object can scale anywhere from half its default size (0.5) to double its default size (2.0)



Replace your previous hard-coded X and Y values with your new 

Now both the X and Y scale will use your random value — creating a proportional shape that changes size with each new instance.

3.  Quickly test and retest with a keyboard shortcut in Unity:

Each obstacle will now appear at a slightly different size.

Try exiting and entering Play mode a few more times to see the obstacles change in size each time.

To decrease loading time each time you enter Play mode, you can disable reloading the domain and scene in the Editor settings. 

You’ve now used a variable and random number generation to make your obstacles more dynamic — a key part of making games feel less repetitive.

Add randomized size logic

Right now, your script uses specific numbers (

) to set the random size. This works — but what if you wanted to adjust those values later? Rather than editing them directly inside the 

 function somewhere in the middle of your code, it’s better to store them as global variables at the top of your script. This makes your code easier to read and modify.

In this step, you’ll move your size range values into variables and make your code more flexible.

1.  Add two new variables at the top of your script:

 script, after the first opening curly brace (

 Placing variables outside of methods lets you reuse them in multiple places. You’ll learn more about scope and variable placement later.

2.  Update your random size line to use the new variables:

Return to Unity and enter Play mode — you should still see varying obstacle sizes as you did before, but now they’re using cleaner code!

You’ve cleaned up your code by using variables instead of hard-coded numbers — a best practice in programming.

Create variables for size range

It can be surprisingly frustrating when your code looks messy — misaligned brackets and inconsistent spacing can make even simple logic harder to read and debug. Keeping your code nicely indented not only improves its readability, but it also helps you spot structural mistakes faster. Fortunately, most code editors come with shortcuts that let you automatically format your code with proper indentation.

Change the spacing or alignment of some of your code to simulate disorganized formatting.

This will help you see the effect of the auto-indent clearly.


If you're using another IDE or if the above shortcuts aren’t working for some reason, search for the keyboard shortcut to "Format Document" or "Auto-indent".

Your code should now snap back into a clean, well-structured format — making it easier to follow and maintain. Use this shortcut as often as you need to keep your code nice and organized.

Auto-format your code

So far, your obstacles can fall and bounce, but they don’t move on their own. In this step, you’ll apply a force to each one using Unity’s physics system so they shoot off in a direction when the game starts.

To do this, you’ll first need to access the 

 component through code using a method called 

 method to push the obstacle in a direction.

This step introduces a core Unity concept: getting references to components in code.

1.  Add a reference to the Rigidbody 2D component:

 variable declarations, add the following line of code:

This creates a variable that will hold a reference to the obstacle’s 

component. It’s very common among Unity developers to give 

2.  Get the Rigidbody 2D component in Start():

 method, below your code that scales the 

 searches the current GameObject for a specific type of component. Unity will find the 

component so you can use it in your code.

 is required syntax — it just means “run this method with no extra info.” Yes, it looks strange at first, but you’ll see this pattern a lot in C# scripts.

, add the following line of code below your other code:

 means “move right along the x-axis.”

You are just moving all the obstacles in a single specific direction for now — you’ll randomize this direction in the coming steps.


Return to Unity and enter Play mode — the obstacle should now initially move to the right as it’s falling down.

Apply force to the obstacles

Right now, your obstacle moves — but gravity is still pulling it downward. In your game, you want the obstacles to float and bounce freely without falling over time. To achieve that, you’ll set the 

Since the obstacle is a prefab, you’ll update the value directly in the prefab so all instances inherit the change.

Enter Play mode. The obstacle will now move in a straight line without falling.

Set gravity scale to zero

In this step, you’ll make each obstacle move at a random speed using the same technique you used to randomize the size: define a range and pick a random value within it.

This will add variety and make the game feel more dynamic.

1.  Add two new variables for speed range:

 variables, add the following lines of code:

These values define the slowest and fastest speeds each obstacle can have.

This picks a new speed for each obstacle when the game starts.

3. Replace the fixed force with your random value.

 line to use your new variable instead of the hardcoded 100 value:

Return to Unity and enter Play mode — each obstacle will now launch at slightly different speeds each time you test the game.

Randomize the speed

Right now, all obstacles launch in the same direction. In this step, you’ll replace the fixed 

 direction with a random 2D direction using the very helpful  

This function gives you a random point inside a circle with a radius of 1 — perfect for generating unpredictable motion in 2D space.

 — pointing in a random direction within a circular area.

2.  Use the random direction to apply force:

Update your force line to use the following new variable:

This will apply your random speed in a random direction for each obstacle.

Return to Unity and enter Play mode — each obstacle will now launch in a new random direction and speed each time you start the game.


You've now combined randomized direction and speed — creating the chaotic motion that makes your game feel lively and replayable.

Randomize direction

. These values are currently hidden inside the script, which means you have to edit code every time you want to tweak them.

In this step, you’ll make those variables 

window. This lets you experiment and adjust behavior without touching the code again — a key workflow when collaborating with designers or fine-tuning gameplay.

 variables as follows to make them public:

window for any GameObject that uses the script.

2.  Save your script and check the Inspector window:

window, you’ll now see the exposed variables listed under the 

 button and observe the changes — no code edits needed!

This use of variables is how Unity lets you separate logic (code) from tuning (

window values), which is especially useful when working with non-programmers like artists and designers.

Expose variables in the Inspector window

If you have any errors in your code or you just want to make sure your script matches exactly what has been taught up to this point, feel free to reference or copy the final code sample below. 

Final script sample

Try these optional activities to challenge yourself, build your skills, and improve your project.

 difficulty so that you know what to expect. You can complete one, all, or none of them — it’s totally up to you. If you’re not interested in doing these challenges, mark this step as complete and proceed to the next tutorial.

Take some time to carefully place the obstacles in strategic locations on the screen.

Move the copies around the screen to create an interesting pattern or obstacle field.

Medium: Make larger obstacles move slower

Give your obstacles more weight by adjusting their speed based on their size.

script, before you add force, divide the speed variable by the size variable. 

This will make larger obstacles relatively slower than the smaller ones.

You’ll likely want to increase the minSpeed and maxSpeed variables in the Obstacle component in the Inspector to compensate for this new reduction in speed. 

Make your obstacles rotate unpredictably when they spawn.

script, add the following new variable at the top:

 method, add the following lines of code:

 Optional: More things to try

You’ve written your first full Unity script — giving each obstacle a random size, direction, and speed. In the next tutorial, you’ll create a controllable player GameObject and learn how to have the player GameObject detect mouse input, rotate toward the cursor, and move using thrust.

Next steps

Identify the defaults elements in a new scene, Create and manipulate GameObjects and configure their components.

Scene Building Essentials

NealEdu

Product Manager at Unity

Control the execution of code with common logic structures 

Level 1 Application Scripting

Joy Horvath

Instructional Designer

GameObjects

lunaduranp

3.1 - Overview.mp4

3.3 - Create and attach a new script.mp4

3.5 - Change the size using a fixed value.mp4

3.6 - Add randomized size logic.mp4

3.7 - Create variables for size range.mp4

3.8 - Apply force to the obstacles.mp4

3.9 - Set gravity scale to zero.mp4

3.10 - Randomize the speed.mp4

3.11 - Randomize direction.mp4

3.12 - Expose variables in the Inspector.mp4

3.13 - Medium - Make larger obstacles move slower.mp4

3.13 - Medium - Add randomized spin.mp4

Gaming

Reduce redundancy and improve code's readability by correctly naming variables and methods

Describe common naming conventions including PascalCase and camelCase

Cultivate a code style that is efficient and easy to read

 Implement basic physics for GameObjects 

Apply RigidBody or RigidBody 2D components in order to enable GameObjects to act under the control of physics

Modify the basic properties of a RigidBody or RigidBody 2D component in order to control how the GameObject is affected by physics, including its mass, its drag, and the Scene's gravity

Unity Version 6.0