Pinterest Stumbleupon Whatsapp
Advertisement

Updated 10 August 2017

Introduction

A surprising feature of the internet economy is the rise of indie videogames. Once the exclusive domain of thousand-man, multi-million dollar triple-A studios, a number of toolsets have been developed that bring modern game development resources into the hands of individuals or small, ad-hoc collections of programmers and designers. We’ve previously discussed the best indie games 10 Indie Games So Good, You’ll Forget They’re Indie At All 10 Indie Games So Good, You’ll Forget They’re Indie At All There may be times, however, where you want something different from the indie norm. A game that follows indie values, yet is made with the quality that top-shelf AAA games are known for. Titles like... Read More , so make sure you check those out for some inspiration as to what can be achieved with tools such as Unity.

These indie game development teams have demonstrated an agility and risk-tolerance that, in many cases, allows them to push gameplay innovation faster than their big budget counterparts. A number of shockingly successful indie titles have premiered in recent years, including Minecraft, Limbo, and Super Meat Boy, and even if you don’t have to skills to make games like this, you can make a game using Buildbox How to Make a Video Game in a Week Using Buildbox How to Make a Video Game in a Week Using Buildbox There is a program that makes game development incredibly easy for even those with absolutely no experience in designing video games. It's called Buildbox. Here's why you should try it. Read More .

In the rapidly evolving landscape of indie game development, Unity has emerged as something of a de-facto standard: its low cost, ease of use, and broad feature set make it ideal for rapid game development. Unity is so flexible, that you can even make your own custom game controllers How to Make a Custom Game Controller With Arduino and Unity How to Make a Custom Game Controller With Arduino and Unity Have you ever wanted to design your own game controller? It's easier than you think! Read More with a bit of DIY know how!

Even large studios such as CCP (Developers of Eve Online) use it for rapidly prototyping game concepts. Unity provides a “game engine in a box” — a physics and rendering engine with hooks for several scripting languages, adaptable to virtually any genre of videogame.

While Unity does provide a visual editor for manipulating the game environment, Unity is not a ‘zero programming’ game creator tool. It requires you to program to produce results, but also gives you a much more flexible and powerful tool than any ‘game maker’ program possibly could.

Advertisement

Unity won’t do the work for you, but it does lower the barrier to entry substantially. Starting completely from scratch with C++ and OpenGL, it can take days to get to the point where there’s actually something rendered onscreen. Using Unity, it takes about ten seconds. Unity puts the basic elements of game creation into the hands of novice programmers in a fast, intuitive way.

Today I’ll be guiding you through everything you need to know to make a game in Unity, which is broken down into ten main chapters:

§1–Versions of Unity

§2–Installing Unity

§3–A Brief Introduction to the Object-Oriented Paradigm

§4–Unity Basics

§5–Example: Basic Elements of a Game

§6–Scripting in Unity

§7–Example: Scripting Pong

§8–Exploring the Documentation / Learning More

§9–Building Your Game / Compiling to a Standalone Application

§10-Closing Notes

1. Versions of Unity

Unity comes in two basic flavors: the pro version and the free version. There are a number of differences, but, broadly speaking, the pro version supports a number of visual improvements (like real-time soft shadows and post-processing), and a large number of relatively minor features that are extremely helpful for more complex games.

That said, for most relatively simple games you might want to build, the free version of Unity is perfectly adequate. We’ll break down the key differences below in more detail for those interested.

1.1 Pricing

The free version of Unity is, of course, free. However, there are a few limitations: the free version of Unity cannot be licensed to any company with an annual income of more than $100,000. While such organizations are beyond the scope of this guide, if you suspect you might become such an organization, it’s probably wise to spring for the Pro version.

The Pro version of Unity is $75 a month, or $1500 for a permanent license, and has no limits on what you can do with the games created with it. There is also a 30-day free trial available, which we’ll be using for this guide, in order to give you as complete an overview of the available features as possible. A one-year student license is also available through Studica for $129.

1.2 Features

There are many features absent in the free version of Unity. However, the most important differences are as follows: the free version of Unity lacks a number of rendering options that allow for better-looking, faster-running games (LOD support, screen-space post-processing, advanced shaders, real-time soft shadows, and deferred rendering). It also lacks the full mechanim animation system, and some AI tools.

In general, for complex, large-scale projects, or projects where graphical performance is important, the pro version is worthwhile. I use the pro version, because I develop virtual reality games for the Oculus Rift Oculus Rift Review Oculus Rift Review Virtual Reality is not new, but it's finally affordable and within our grasp. After four year and two development prototypes, the final consumer edition of the Oculus Rift has arrived. Read More , and the screen-space post-processing support is necessary to correctly interact with the headset.

2. Installing Unity

Unity is straightforward to install. You can download the executable from unity3d.com/get-unity/download.

Once downloaded, run it, and then follow the installer instructions. When the installation is finished, a window titled ‘activate your Unity license’ will appear. Check the box marked ‘activate a free 30-day trial of Unity Pro’ and then ‘OK’.

Congratulations! You now have a 30-day trial of Unity Pro. When the trial expires, if you don’t want to buy the pro version, you can switch to the free version and keep your existing content.

3. A Brief Introduction to the Object-Oriented Paradigm

Before getting started started with Unity, it’s important that we go over the basics a little. Unity supports both C# and JavaScript for game programming; we’ll be working with C# for this tutorial.

First off, if you’ve never programmed before, put this tutorial aside and spend a few days working through Microsoft’s C# Language Primer until you feel comfortable using the language for simple tasks.

If you’d like something a bit different to C# (but not necessarily a language you can use in Unity), then take a look at our guide to the six easiest programming languages for beginners 6 Easiest Programming Languages to Learn for Beginners 6 Easiest Programming Languages to Learn for Beginners Learning to program is about finding the right language just as much as it's about the edification process. Here are the top six easiest programming languages for beginners. Read More .

If you have programmed before in an imperative or object oriented language like C or Java, skim the primer and familiarize yourself with how C# differs from other languages you’ve used in the past. Either way, don’t proceed with the tutorial until you feel comfortable solving simple problems with C# (for example, if I were to ask you to write a program that prints the first hundred prime numbers, you should be able to write that program without consulting Google).

The most important concept to understand here is the object-oriented paradigm Where Did "Object Oriented" Programming Get Its Name From? Where Did "Object Oriented" Programming Get Its Name From? Object Oriented isn’t just a random buzzword you hear in programming circles. There’s a reason behind the name - but what? Join me as I explore some of the fundamentals of programming concepts and explain... Read More (abbreviated as OOP). In object oriented languages, programs are divided into functional units called Objects. Each object has its own private variables and functions. Object-specific functions are called methods.

The idea here is modularity: by having each object isolated, and forcing other objects to interact with it through its methods, you can reduce the number of possible unintentional interactions — and, by extension, bugs. You can also create objects you can reuse later with no modification. In Unity, you’ll be building these objects and attaching them to game entities (whose behavior they’ll govern).

Objects are instantiated from classes: a class is just a file that lays out the definition of your object. So, if you want a Mook object that handles AI for an enemy in your game, you’d write a ‘Mook’ class, and then attach that file to every enemy entity. When you run your game, each enemy will be equipped with a copy of the ‘Mook’ object.

Attaching a new script to an object looks like this:

First, select the object and go to the Inspector. Click on the Add Component button.

Go to new script, enter the name you want, and click create and add.

Now you have a new script that you can edit by double-clicking on it!

A class file looks something like this:

using UnityEngine;

public class Mook : MonoBehaviour {
    private float health; 
    void Start () {
        health = 100; 
    }
    void Update(){
        if (health > 0) {
            /* Search for player
            if you encounter the player on the road, kill him
            if you get shot, remove a random amount of health */
        }
    }
}

Let’s break this down:

  • Using UnityEngine: This line tells C# that we want to use Unity’s libraries, which allow us to connect to the Unity game engine.
  • Public class Mook : MonoBehaviour:This line declares the class and its name — Mook.
  • Private float health: This declares a private class variable (which can only be changed from inside the class). The variable is given a value in Start.
  • Void Start(): This declares a method called Start. Start is a special method that runs only once, when the game initially launches.
  • Void Update(): Update is another special method, which runs on every frame. Most of your game logic will go here.
  • //if you encounter the player on the road, kill him: This line is a comment (any line starting with a double slash is ignored by C#). Comments are used to remind yourself of what particular bits of code do. In this case, this comment is being used to stand in for a more complicated block of code that actually does what the comment describes.

Along with Start and Update, you can instantiate your own methods with almost any name. However, methods that you create won’t run unless they’re called. Let’s declare a method for a hypothetical class called addTwoNumbers that adds two numbers together:

public float addTwoNumbers(float a, float b) {
    return a+b;
}

This declares a public (accessible to other objects) method that returns a float, called addTwoNumbers, which takes two floats as input (called a and b). It then returns the sum of the two values as its output.

Calling this method from within the same class (say, from inside Update) looks like this:

float result = addTwoNumbers(1, 2);

Calling the method from another class is similar:

addTwoNumbers instance;
float result = instance.addTwoNumbers(1, 2);

Again, this just creates an instance of our class, accesses the appropriate method and feeds it the numbers we want to add, then stores the result in result. Simple.

If your script is attached to an object that has special properties (like a particle emitter) that can’t be accessed under the normal set of GameObject parameters, you can choose to treat it as a different kind of game entity by using the GetComponent method.

The syntax for that looks like this:

GetComponent<ParticleSystem>().Play();

If any of this is unfamiliar to you, go back and go through the C# primer. It’ll save you a lot of frustration as we proceed.

4. Unity Basics

In this section, we’re going to work our way through the basic mechanics of the Unity engine. The workflow in Unity goes something like this:

  1. Create an entity to serve a role in the game (blank GameObjects can be used for abstract logical tasks).
  2. Write or find a class file, and add it to the entity as a script (using the Add Component button in the inspector view.
  3. Run > test > debug > repeat until it works and move on to the next element of the game.

Unity comes with a number of basic view tabs that can be laid out in various ways to the taste of the user. The big five are:

  1. Game: displays a running instance of the game that you can interact with and test.
  2. Scene: provides a static, editable version of the game world.
  3. Inspector: allows you to modify individual entities in the game world by selecting them in the editor tab.
  4. Project: allows you to browse through the project’s files and drag models, materials, and other resources into the editor tab to place them in the game world.
  5. Hierarchy: this tab shows all objects in the world, allowing you to find distant objects in the scene, and parent entities to one another by clicking and dragging.

See the diagram below for the locations of all these things:

4.1 Unity Entities

4.1.1 Meshes

Meshes are the way 3D geometry is represented in Unity. You can either use Unity’s built-in primitive objects (cubes, spheres, cylinders, etc), or import your own 3D models from a modelling package like Blender Getting Started with Blender: 7 Fantastic Tutorials for Newbies Getting Started with Blender: 7 Fantastic Tutorials for Newbies 3D modeling is an excellent way to exercise creativity while keeping in touch with your technical side. Here are some awesome free tutorials. Read More or Maya Learning Maya 2016: Where To Get Started Learning Maya 2016: Where To Get Started Maya is a tool used for 3D animation, but it comes with an incredibly steep learning curve. What good teaching material is there? Read More . Unity supports a variety of 3D formats, including .fbx, and .3ds.

The basic tools for manipulating meshes are the scaling, rotation, and translation buttons in the upper left corner of the interface. These buttons add control icons to the models in the editor view, which can then be used to manipulate them in space. To alter the texture or physics properties of an object, select them and use the inspector view to analyze the material and rigidbody elements.

4.1.2 GUI Elements

Traditional GUI sprites and text can be displayed using the GUI Text and the GUI Texture GameObjects in the editor. However, a more robust and realistic way to handle UI elements is to use the 3D text and Quad GameObjects (with transparent textures and an unlit transparent shader) to place HUD elements into the game world as entities.

In the hierarchy view, these gameplay elements can be dragged onto the main camera to make them children, ensuring that they move and rotate with the camera.

GUI elements (text and textures) can have their size and scale adjusted using the relevant fields in the inspector tab.

4.1.3 Materials

Materials are combinations of textures and shaders Five Important PC Gaming Terms Explained Five Important PC Gaming Terms Explained If you play a game on a console, the technical details are handled for you. Some players prefer this, but PC gamers often enjoy the greater degree of control they have over a game’s eye... Read More , and can be dragged directly onto game objects from the project tab. A large number of shaders come with Unity Pro, and you can adjust the texture attached to them using the inspector tab for an object that they’re applied to.

To import a texture, convert it to a .jpg, .png, or .bmp, and drag it into the assets folder under the Unity project directory (which appears in My Documents by default). After a few seconds, a loading bar will appear in the editor. When it finishes, you’ll be able to find the image as a texture under the project tab.

4.1.5 Lights

Lights are GameObjects which project radiance onto the world. If there are no lights in your scene, all polygons are drawn at the same brightness level, giving the world a flat, washed-out look.

Lights can be positioned, rotated, and have several internal characteristics that you can customize. The intensity slider controls the brightness of the light, and the range controls how quickly it fades out.

The guidelines in the scene view show you the maximum range of the illumination. Play with both settings to achieve the desired effect. You can also adjust the color of the light, the pattern (cookie displayed on the surface the light is pointed at, and what kind of flare appears onscreen when looking directly at the light. The cookie can be used to fake more realistic light patterns, create dramatic false shadows, and simulate projectors.

The three main kinds of light are spot, point, and directional.

Spot lights have a location in 3D space and project light only in one direction in a cone of variable angle. These are good for flashlights, searchlights, and, in general, give you more precise control of lighting. Spot lights can cast shadows.

Point lights have a location in 3D space, and cast light evenly in all directions. Point lights do not cast shadows.

Directional lights, finally, are used to simulate sunlight: they project light in a direction as though from infinitely far away. Directional lights affect every object in the scene, and can produce shadows.

4.1.6 Particle Systems

A Particle system is a GameObject that generates and controls hundreds or thousands of particles simultaneously. Particles are small, optimized 2D objects displayed in 3D space. Particle systems use simplified rendering and physics, but can display thousands of entities in real time without stuttering, making them ideal for smoke, fire, rain, sparks, magic effects, and more.

There are a lot of parameters that you can tweak to achieve these effects, and you can access them by spawning a particle system under the component editor > selecting the particle system > opening the inspector tab. You can change the size, speed, direction, rotation, color, and texture of each particle, and set most of those parameters to change over time as well.

Under the collision attribute, if you enable it and set the simulation space to world you’ll get particles that will collide with objects in the world, which can be used for a number of realistic particle effects, including rain, moving water, and sparks.

5. Example: Basic Elements of a Game

For this tutorial, we’re going to make a simple game of Pong — something that we’ve covered several times in DIY before:

In this section, we’ll go over arranging the core elements — the scripting tutorial will come later.

First, let’s break down the game of Pong into its basic components. First, we need two paddles, and a ball. The ball flies offscreen, so we’ll want a mechanism to reset it. We also want text to display the current score, and, for the sake of showing you all the core elements of Unity, we’ll want a fancy particle effect when you hit the ball. The whole game will need to be dramatically lit.

That breaks down into a ball object (a sphere), a spawner, two paddle props with particle emitters attached, a 3D-text entity, and a spot light. For this tutorial, we’ll be using the default physic material bounce, with bounce combine set to multiply. Here’s what the setup looks like, in ten screenshots:

First, create a cube prop for the paddle.

Scale it appropriately, duplicate it, and put a sphere between the paddles for the ball.

Then, create a 3DText object and scale and position it correctly, changing the font size attribute to get a less pixelated image.

Next, create two particle systems, pick the characteristics you want, and attach them to the paddles.

Next, you’ll want to position and rotate the camera so that it frames the scene correctly. While the camera is selected, you can see a small preview of the camera’s view in the lower right hand corner.

Before we finish, we need to create two additional cubes to be bumpers, to prevent the ball from bouncing out of the game area. We can make them invisible by unchecking the mesh renderer in the inspector tab.

If you hit play, you can now see the basic elements of our game laid out. They won’t do anything yet, but we’ll get to that!

Now that we’ve got that setup, we’re going to talk about what’s involved in scripting these elements to make a game.

6. Scripting in Unity

Once you have a script attached to an object, you can revise it by double clicking on it in the inspector. This opens MonoDevelop, the default development environment for Unity. In essence, Monodevelop is a text editor with features specifically optimized toward programming.

Keywords and comments are highlighted in blue and green, and numerical values and strings appear in red. If you’ve used Eclipse or other IDE’s, MonoDevelop is very similar. You can build your scripts from inside the editor, to check for syntax errors, like so:

In general, to get your script to interact with Unity, you’ll need to reference elements that the object holding the script possesses (you can see a list of these elements under the inspector tab when the relevant object is selected). You can then call methods or set variables for each of these elements to enact the changes you want.

If you want a script on an object to affect the properties of a different object, you can create an empty GameObject variable in your script, and use the inspector to assign it to another object in the scene.

A list of the elements an object might have is as follows (taken from the inspector view of one of our paddles in the above example):

  1. Transform
  2. Cube (Mesh Filter)
  3. Box Collider
  4. Mesh Renderer

Each of these aspects of the object can be influenced from within a script. Next, we’ll look at exactly how.

6.1 Transform

The transform functions for a GameObject in Unity control the physical parameters of that object: its scale, its position, and its orientation. You can access them from within a script like this:

transform.position = newPositionVector3;
transform.rotation = newRotationQuaternion;
transform.localScale = newScaleVector3;

In the above examples, the named variables are of the types specified in the names. There are a few key details here: position and scale are, as you’d expect, stored as Vector3s. You can access the X, Y, and Z components of each (for example, transform.position.y gives you the distance of an object above the zero plane).

However, to avoid gimbal lock, rotations are handled as Quaternions (four-component vectors). Because hand-manipulating quaternions is unintuitive, you can manipulate rotations using Eulerian angles by using the Quaternion.Euler method like so:

transform.rotation = Quaternion.Euler(pitch, yaw, roll);

If you wish to move objects smoothly from one place to another, you’ll find the Slerp method for quaternions and vector3s helpful. Slerp takes in three arguments – the current state, the final state, and the speed of change, and smoothly interpolates between them at the given speed. The syntax looks like this:

transform.position = Vector3.Slerp(startPositionVector3, newDestinationVector3, 1);

6.2 Renderer

The renderer functions in Unity allow you to control the way the surfaces of props are rendered on-screen. You can reassign the texture, change the color, and change the shader and visibility of the object. The syntax looks like this:

renderer.enabled = false; 
renderer.material.color = new Color(0, 255, 0); 
renderer.material.mainTexture = myTexture; 
renderer.material.shader = newShader;

Most of these have pretty clear functions. The first example makes the object in question invisible: a useful trick in a number of situations. The second example assigns a new RGB color (namely, green) to the object in question. The third assigns the main diffuse texture to a new Texture variable. The last example changes the shader of the object’s material to a newly defined shader variable.

6.3 Physics

Unity comes with an integrated physics engine — something that physics sandbox games Smash, Drive & Build: 3 Awesome Physics Sandboxes Simulators Smash, Drive & Build: 3 Awesome Physics Sandboxes Simulators Read More all use. This allows you to assign the physical properties of objects and let the details of their simulation be handled for you. In general, rather than trying to implement your own physics using a textbook and the transform system, it is simpler and more robust to use Unity’s physics engine to the greatest extent possible.

All physics props require colliders. However, the actual simulation itself is handled by a rigidbody, which can be added in the inspector view. Rigidbodies can be kinematic or nonkinematic.

Kinematic physics props collide with (and effect) nonkinematic physics props around them, but are unaffected by collision themselves. Static kinematic props are the proverbial immoveable objects, and moving kinematic objects are the proverbial unstoppable force (for the record, when they collide, they simply pass through each other).

Beyond that, you can adjust the angular drag of the object (how much energy it takes to spin it), change its mass, dictate whether or not it’s affected by gravity, and apply forces to it.

Examples:

rigidbody.angularDrag = 0.1f;
rigidbody.mass = 100;
rigidbody.isKinematic = false;
rigidbody.useGravity = true;
rigidbody.AddForce(transform.forward * 100);

These are all pretty self-explanatory. The only thing to note here is the use of transform.forward. Vector3’s all have three components (.forward, .up, and .right) associated with them, which can be accessed and rotates with them (forward is the direction of the blue arrow in the editor). The transform.forward keyword is simply the forward vector for the current object with magnitude 1. It can be multiplied by a float to create more force on the object. You can also reference transform.up and transform.right, and negate them to get their reverses.

6.4 Collision

Often, when building a game, you’d like a collision to result in some change-of-state in your code, beyond just physics simulation. For this, you’ll need a collision detection method.

There’s a certain amount of prep work needed to detect collisions in Unity. First, at least one of the objects in the collision needs a non-kinematic rigidbody attached to it. Both objects must have correct colliders, set to be non-triggers. The total speed of both objects must be low enough that they actually collide, instead of simply skipping through one another.

If you’ve got all that taken care of, you can check for collision by placing a special collision detection method in a script attached to the object you’d like to check collision with. The method will look like this:

void OnCollisionEnter(Collision other) {
    //do things here
}

This method will automatically run during the first frame that another object touches your object. The collision entity other is a reference to the object that you hit. You can, for example, reference its gameobject, rigidbody, and transform characteristics to manipulate it in various ways. While OnCollisionEnter is probably the most common function you’ll be using, you can also use OnCollisionExit and OnCollisionStay (with otherwise identical syntax and usage), which activate during the first frame that you stop colliding with an object and during every frame that you’re colliding with an object, respectively.

Sometimes, it can also be useful to do what’s called raycasting. In raycasting, an infinitely thin line (a ray) is cast through the world from some origin, along some vector, and, when it hits something, the position and other details of the first collision are returned. The code for a raycast looks like this:

RaycastHit hit;
if (Physics.Raycast(transform.position, -Vector3.up, out hit)) {
    float distanceToGround = hit.distance;
}

This casts a ray from the position of the current object along -Vector3.up (straight down), and links the variable hit to the first object it collides with. Once your ray has hit something, you can access hit.distance to determine how far away it is, or hit.GameObject to manipulate the object you hit.

Raycasts like this can be used for shooters to determine what the gun’s pointed at, or to select objects when the camera looks at them, or for certain styles of movement mechanic.

6.5 Time Correction

One important factor to keep in mind when you’re manipulating objects in this way has to do with framerate. No matter how carefully you optimize, framerates will always vary, and you don’t want your game speed to vary accordingly. If someone else runs your game on a faster computer than you developed it on, you don’t want the game to run at double speed.

The way you correct for this is by multiplying the values you’re using by the time it took to render the last frame. This is done by using Time.deltaTime. This effectively changes the speed of any variable you’re incrementing every frame from change per frame to change per second, and you should probably make this change to any value you’re incrementing or decrementing every frame.

6.6 Audio Sources and Listeners

Now that we’ve covered how to create, render, and control objects, let’s talk about the other sense that computer games can serve: namely, sound. Unity supports two kinds of sounds: 2D and 3D sounds. 3D sounds vary their volume based on distance, and distort as they move relative to the camera; 2D sounds do not.

2D sounds are appropriate for voice-overs and background music, and 3D sounds apply to sounds generated by events in the world. In order to change whether or not a sound is 3D, select it in the project view, switch to the inspector view and select the appropriate option from the dropdown menu, then press the reimport button.

In order to actually play the sound, you’ll need to attach an audiosource to a prop (the prop you want the sound to originate from, in the case of a 3D sound). Then you’ll need to open the audioclip field and select your sound file.

You can use myAudioSource.Pause() and myAudioSource.Play() to control those sound files. You can adjust the falloff behaviors, volume, and doppler shifting of the sounds under the inspector tab for the audiosource.

6.7 Input

A game that doesn’t take any input from the user isn’t much of a game. There are a lot of different kinds of input you can read in, and almost all of them are accessible through the Input and KeyCode objects. Some sample input statements (which have a values evaluated every frame) are below.

Vector3 mousePos = Input.mousePosition;
bool isLeftClicking = Input.GetMouseButton(0);
bool isPressingSpace = Input.GetKey(KeyCode.Space);

The functions of these lines is mostly self explanatory. Using these three kinds of input reference, you can reconstruct the control schemes of most modern 3D computer games.

6.8 Debugging a Script

Let’s say a script doesn’t work. As the good doctor says, bangups and hangups can happen to you. If there are outright syntax errors with your C#, the game will generally refuse to run when you hit play, and some fairly useful error messages are provided if you build the scripts from within the editor. See below:

These bugs are typically not the most difficult to fix. What can be more problematic are subtle semantic errors, in which you have successfully written a file full of valid C# – just not one that does what you thought it would. If you have one of these errors, and you’re having trouble tracking it down, there are a few things you can try to improve the situation.

The first is to pause the execution of the game, and check the console. You can pause the game by clicking on the pause icon in the upper middle portion of the editor, and then selecting console from the bottom of the window menu (or pressing Ctrl > Shift > C). Even if there are no errors, warnings can still help to give some clues as to what might be going wrong.

If this doesn’t work, you can also try to get some idea about the state of your script by printing the state of internal variables to validate that the program is doing what you think it’s doing. You can use Debug.Log(String) to print the contents of a string to the console when the program execution hits that line. In general, if you work backwards from what you think should be happening through the things that should be making it happen, eventually you will reach a point where your debug prints don’t do what you expect them to do. That’s where your error is.

7. Example: Scripting Pong

To build Pong, let’s break the game down into its core elements: we need a ball that ricochets back and forth between the paddles at increasing speed, we need a scoreboard that knows when the balls have passed the paddles, and we need a mechanism for restarting the ball when that happens. A good first step would be to add a non-kinematic rigidbody to the ball, two kinematic rigidbodies to the paddles, disable gravity for all of them, and assign an appropriate physic material from the standard assets (bounce with bounce combine set to multiply).

Below, you can view the script for the ball with explanatory comments. The ball needs to accomplish some basic goals: it should bounce in a complicated pattern, always maintaining movement on both axes, and it should accelerate at a challenging but not impossible pace in the horizontal direction.

BallHandler.cs

Next, we need to script our paddle, which you can view below. The paddle needs to move up and down in response to key presses (but not outside certain bounds). It also needs to trigger the particle system when it collides with something.

PaddleHandler.cs

Next, we need enemy AI: something that will cause the enemy’s paddle to track towards the ball at a fixed rate. For that, we’ll be using Vector3.Slerp for maximum simplicity. We’d also like the same particle behavior that we see on our own paddle.

EnemyAI.cs

Finally, we need a script to update the scoreboard and reset the ball when it goes out of bounds.

ScoreboardUpdater.cs

With those scripts attached and the references filled in, when we run our game of Pong, we experience gameplay!

You can download my Pong demo, if you’d like to see everything I’ve outlined in action. It runs on Windows, Mac and Linux systems.

8. Exploring the Documentation / Learning More

Unity is a complex engine with many more features than could feasibly be covered in a guide of this style, and that’s before you include the wide swathe of (free and commercial) Unity extensions available on the internet. This guide will give you a strong starting place for developing a game, but self-education is an important skill in any endeavor, and doubly so here.

A crucial resource here is the Unity ScriptReference. The ScriptReference is a searchable database, available for both C# and Javascript, which has a list of every Unity command and feature, with descriptions of their functions and brief examples of syntax.

If you’re having trouble with the editor and interface of Unity, or just like video tutorials as a matter of preference, there is a long list of high-quality Unity video tutorials available. More extensive (but less broad) text tutorials for Unity are also available from CatLikeCoding.

Finally, if you have questions beyond the scope of documentation or tutorials, you can ask specific questions at answers.Unity3d.com. Remember that answers are provided by volunteers, so respect their time and search the database first to make sure your question hasn’t already been answered.

9. Building Your Game / Compiling to a Standalone Application

When you’ve built something you’re proud of (or you’ve finished cloning our slightly dodgy Pong example for practice), it’s time to move your game from the editor and turn it into something that you can post on the internet and force your friends and family to play. In order to do that, you’ll need to build a standalone application. The good news is that in Unity, this is very, very easy. There are, however, a few potential hiccoughs that you’ll want to be careful of.

For starters, know that you can only build an error-free project. To that end, make sure you have the console open as you build: there are some error conditions that the game will ignore in the editor, but will still abort an attempted build. This only dumps error messages to the console, with no visible results onscreen, which can be frustrating if you forget to check. Once you’ve got your game compiling error-free, though, you can select Build Settings under the File menu, or press Ctrl > Shift
> B. This will bring up a simple dialog that allows you to build your game for several platforms.

The process from there is self explanatory: select your options, and hit build; the game will prompt you for a directory to install to, and will place both the executable and data directory there. These two files can be zipped together and distributed (just make sure you aren’t charging for a game built in the Unity demo, as this violates the terms of service).

10. Closing Notes

As with any game development tool, the key to success with Unity is iterative development. You have to build in manageable increments — be ambitious, by all means, but be ambitious in small chunks, and arrange those chunks such that, even if you fall short of your ultimate ambition, you’ll at least wind up with a coherent product.

Get the most crucial elements in first: have an idea in mind of your minimum viable product, the simplest, most bare-bones thing you could possibly create and still feel as though you achieved something worthwhile. Get to that minimum viable project before moving on to larger ambitions.

This tutorial gives you a strong starting place, but the best way to learn Unity is by building a game. Start building a game, fill gaps in your knowledge as they come up, and the gradual flow of knowledge will erode away the things you don’t know surprisingly quickly.

If you’ve read all this and are a bit overwhelmed by the coding required with Unity, make sure you read our guide on how to make video games without any programming How to Make Video Games Without Any Programming How to Make Video Games Without Any Programming Want to make a video game but can't code? Then use a video game construction kit that lets you build games without any coding required! Read More .

Unity is a powerful tool, and with a bit of exploration, you can be building impressive projects with it quicker than you might expect. Let us know what you built in the comments below — we’d love to see!

Leave a Reply

Your email address will not be published. Required fields are marked *

  1. gfddfg
    April 3, 2017 at 8:16 pm

    this does not make any sense
    you start with a scene, without even saying how to get there

    "select an object" my scene is empty

  2. Sandeep K
    January 24, 2017 at 4:56 am

    Please tell the writer name of C# Primer. There are confusion over the google with many books name.

  3. Lucas
    October 13, 2016 at 4:01 pm

    Great guide! if you are looking for more tips about creating a game I highly recommend blog.theknightsofunity.com

  4. gul
    March 30, 2016 at 6:17 am

    great article

  5. Daniel
    February 9, 2016 at 8:51 pm

    Thank you, it helped a lot! :)

  6. Anonymous
    October 13, 2015 at 8:29 am

    Starting was interesting, but kinda confusing from the mid....

  7. mattbat
    December 25, 2014 at 12:55 am

    Its a little confusion filled tutorial, but I unfer stand it a little?

    • Sam
      January 18, 2015 at 9:59 pm

      There's no 3D text!! Where is it??

    • Alto Stratous
      April 2, 2015 at 11:03 am

      Don't mention the weakness only. Please admire this article as an introduction to Unity.

      • Anonymous
        October 12, 2015 at 12:27 am

        soz wrong chat