Unity Game Development Scripting

Chapter 1. Interactive Input

Before we start creating our game, it is a good idea to figure out our controls. We'll create a script that will hold our inputs, and create control profiles for both the keyboard/mouse as well as the Xbox 360 Controller. Then, we'll add functionalities to be able to switch between the profiles and customize them as well. Control configurations like these are a key element to games, especially PC games.

In this chapter, we will cover the following topics:

Creating controls for the Xbox 360 Controller
Creating controls for a keyboard
Writing a function to detect whether our controller device is plugged in
Customizing our controls
Letting players switch controls
Switching controls with Graphical User Interface (GUI) buttons
Resetting controls back to factory settings

Picking the controls

Before we start creating our game, we should decide how the player will play the game. The controls are one of the most key parts of a game.

Mapping the needed controls

For the game that we will create, we will need several controls. Some are already included in the input manager within Unity, while some are not. The following table shows what default controls we will be using, and what buttons we'll use for them:

Action	Keyboard/mouse	Xbox 360 Controller
Movement	WASD keys	Left thumbstick
Rotate camera	Mouse	Right thumbstick
Item bar buttons	1234 keys	Directional pad
Inventory	The I key	The A button
Pause game	The Esc key	The Start button
Attack / use an item	The left mouse button	The right trigger
Aim	The right mouse button	The left trigger

Checking the input manager

In the following screenshot, you can see that there are default inputs already implemented, which we can use for the movement, rotate camera, attack/use item, and aim actions:

As you can see, we still need to add inputs for the inventory, pause game, and item bar buttons. We will also need to make sure that the inputs we enter will support inputs from the Xbox 360 Controller.

Checking the Xbox 360 Controller inputs

Before we add stuff into the input manager, we should take a look at what the inputs are on the Xbox 360 Controller. This will help us integrate the controller inputs in the input manager, as well as give us an insight on how to code the controller inputs.

Adding additional controller inputs

To get started, access your input manager by navigating to the Edit menu, hovering over Project Settings, and clicking on Input. Open up the Axes dropdown by clicking on the arrow next to it and change the number in the Size parameter to be a value higher. This will add another input at the bottom of the list, which we can use for one of our types of inputs.

By default, by creating a new type of input, the input manager duplicates the bottom input. So open it and we'll make our changes. Follow these steps to create our new input:

Change the value of the Name parameter to A_360.
Change the value of the Positive Button parameter to joystick button 0.

Adding a start button and trigger inputs

As you can see, it's fairly easy to add an Xbox 360 input in the input manager. You can follow the same steps to add the start button; just change the value of the Name parameter to Start_360 and the value of the positive button to joystick button 7. For the two triggers, you will need to follow slightly different steps:

Change the value of the Name parameter to Triggers_360.
Change the value of the Sensitivity parameter to 0.001.
Check the Invert parameter.
Change the value of the Type parameter to Joystick Axis.
Change the value of the Axis parameter to 3rd Axis (Joysticks and Scrollwheel).

Adding directional pad inputs

For the directional pad, we'll need to make the horizontal buttons and vertical buttons separately, but these will both be similar to how we set up the triggers. First, we will create the horizontal directional pad input:

Change the value of the Name parameter to HorizDpad_360.
Change the value of the Sensitivity parameter to 1.
Change the value of the Type parameter to Joystick Axis.
Change the value of the Axis parameter to 6th Axis (Joysticks).

For the vertical directional pad input, you can follow the exact same steps as we did for the horizontal directional pad input; just change the value of Name to VertDpad_360 and change the value of Axis to 7th Axis (Joysticks). This completes the Xbox 360 Controller inputs; all that's left are the PC inputs.

Adding PC control inputs

Most of our PC control inputs are already integrated into the input manager; all that is left are the number keys, I key, and Esc key.

You can actually follow the same steps as at the beginning of this chapter, when we added the Xbox 360 buttons. For the number keys you'll want to change each of their names to num1, num2, num3, and num4. As for their positive button parameters, change their names to 1, 2, 3, and 4, accordingly.

The I key name will be I_Key and its positive button parameter will be i. For the Esc key, we will want the Name parameter to be Esc_Key and its positive button parameter will be escape.

Creating the device detector

The first function we'll create is one that will detect whether we actually have a gamepad plugged in. Unity inherently gives us a way to make this very easy.

Adding the variables needed

First, we'll add variables that we'll use in the detection and identification functions. Add these to the top of your script, just after the class declaration:

bool isControllerConnected = false;
public string Controller = "";

This Boolean will be used in later functions to determine whether there is a gamepad connected. The string will be used to hold the name of the gamepad connected.

Creating the detection function

Our next step is to add the DetectController function. This will use the Boolean we created earlier and check whether there is a gamepad connected. Add the following code to your script:

void DetectController()
{
  try
  {
    if(Input.GetJoystickNames()[0] != null)
    {
      isControllerConnected = true;
      IdentifyController();
    }
  }
  catch
  {
    isControllerConnected = false;
  }
}

This function uses the GetJoystickNames function of the input, which gets and returns an array of strings, which consists of the names of the connected gamepads. We use this to set our Boolean to true or false; true meaning there's a device connected and false meaning that the game couldn't detect a device. The reason we use a try-catch expression is because if there is no gamepad connected Input.GetJoystickNames() will give you an IndexOutOfRangeException error.

Creating the identifier function

Our last step in creating the device detector will be to add the ability to identify the gamepad connected. Add this function to the script, just below the DetectController function:

void IdentifyController()
{
  Controller = Input.GetJoystickNames()[0];
}

As you can see, we are assigning the name of the gamepad connected to our Controller variable. To use this function, call it within the DetectController function, in the if statement, where we set isControllerConnected to true.

Let's get set and show them

The next step in our Control script is to set up our controls to be able to customize what they do, and display what each control does.

Adding variables for each control

At the top of your script, after your other variables, add these new variables:

public string PC_Move, PC_Rotate, PC_Item1, PC_Item2, PC_Item3, PC_Item4, PC_Inv, PC_Pause, PC_AttackUse, PC_Aim;
public string Xbox_Move, Xbox_Rotate, Xbox_Item1, Xbox_Item2, Xbox_Item3, Xbox_Item4, Xbox_Inv, Xbox_Pause, Xbox_AttackUse, Xbox_Aim;

We will use these variables to display our controls on the screen. Later, we'll use them for customization as well. Add this code to assign the default values to our new variables:

void SetDefaultValues()
{
  if(!isControllerConnected)
  {
    PC_Move = "WASD";
    PC_Rotate = "Mouse";
    PC_Item1 = "1";
    PC_Item2 = "2";
    PC_Item3 = "3";
    PC_Item4 = "4";
    PC_Inv = "I";
    PC_Pause = "Escape";
    PC_AttackUse = "Left Mouse Button";
    PC_Aim = "Right Mouse Button";
  }
  else
  {
    PC_Move = "WASD";
    PC_Rotate = "Mouse";
    PC_Item1 = "1";
    PC_Item2 = "2";
    PC_Item3 = "3";
    PC_Item4 = "4";
    PC_Inv = "I";
    PC_Pause = "Escape";
    PC_AttackUse = "Left Mouse Button";
    PC_Aim = "Right Mouse Button";
    Xbox_Move = "Left Thumbstick";
    Xbox_Rotate = "Right Thumbstick";
    Xbox_Item1 = "D-Pad Up";
    Xbox_Item2 = "D-Pad Down";
    Xbox_Item3 = "D-Pad Left";
    Xbox_Item4 = "D-Pad Right";
    Xbox_Inv = "A Button";
    Xbox_Pause = "Start Button";
    Xbox_AttackUse = "Right Trigger";
    Xbox_Aim = "Left Trigger";
  }
}

We will set these variables in a function because later we will use this function again to reset the controls if they are customized. The function uses our isControllerConnected variable to determine whether a gamepad is plugged in or not, and then assigns the appropriate data.

Adding a function to display the variables

Next, we will use the OnGUI function to display our controls onto the screen. We will create a menu that will show each action and their controls for a PC and Xbox 360 Controller, very similar to the table shown at the beginning of this chapter. Add this code to the bottom of your script:

void OnGUI()
{
  GUI.BeginGroup(new Rect(Screen.width/2 - 300, Screen.height / 2 - 300, 600, 400));
  GUI.Box(new Rect(0,0,600,400), "Controls");
  GUI.Label(new Rect(205, 40, 20, 20), "PC");
  GUI.Label(new Rect(340, 40, 125, 20), "Xbox 360 Controller");

  GUI.Label(new Rect(25, 75, 125, 20), "Movement: ");
  GUI.Button(new Rect(150, 75, 135, 20), PC_Move);
  GUI.Button(new Rect(325, 75, 135, 20), Xbox_Move);

  GUI.Label(new Rect(25, 100, 125, 20), "Rotation: ");
  GUI.Button(new Rect(150, 100, 135, 20), PC_Rotate);
  GUI.Button(new Rect(325, 100, 135, 20), Xbox_Rotate);

  GUI.Label(new Rect(25, 125, 125, 20), "Item 1: ");
  GUI.Button(new Rect(150, 125, 135, 20), PC_Item1);
  GUI.Button(new Rect(325, 125, 135, 20), Xbox_Item1);

  GUI.Label(new Rect(25, 150, 125, 20), "Item 2: ");
  GUI.Button(new Rect(150, 150, 135, 20), PC_Item2);
  GUI.Button(new Rect(325, 150, 135, 20), Xbox_Item2);

  GUI.Label(new Rect(25, 175, 125, 20), "Item 3: ");
  GUI.Button(new Rect(150, 175, 135, 20), PC_Item3);
  GUI.Button(new Rect(325, 175, 135, 20), Xbox_Item3);

  GUI.Label(new Rect(25, 200, 125, 20), "Item 4: ");
  GUI.Button(new Rect(150, 200, 135, 20), PC_Item4);
  GUI.Button(new Rect(325, 200, 135, 20), Xbox_Item4);

  GUI.Label(new Rect(25, 225, 125, 20), "Inventory: ");
  GUI.Button(new Rect(150, 225, 135, 20), PC_Inv);
  GUI.Button(new Rect(325, 225, 135, 20), Xbox_Inv);

  GUI.Label(new Rect(25, 250, 125, 20), "Pause Game: ");
  GUI.Button(new Rect(150, 250, 135, 20), PC_Pause);
  GUI.Button(new Rect(325, 250, 135, 20), Xbox_Pause);

  GUI.Label(new Rect(25, 275, 125, 20), "Attack/Use: ");
  GUI.Button(new Rect(150, 275, 135, 20), PC_AttackUse);
  GUI.Button(new Rect(325, 275, 135, 20), Xbox_AttackUse);

  GUI.Label(new Rect(25, 300, 125, 20), "Aim: ");
  GUI.Button(new Rect(150, 300, 135, 20), PC_Aim);
  GUI.Button(new Rect(325, 300, 135, 20), Xbox_Aim);
  GUI.EndGroup();
}

The preceding code is fairly self-explanatory; we use GUI labels to show what actions the player can do, then use the GUI buttons to show what inputs the actions are mapped to. Later, we'll use these buttons as a way to customize our controls.

Customization is key

It's time to customize our controls! We'll go over a couple of ways to add customization to our controls. Unity doesn't allow us to edit the input properties while in-game, so we will create a couple of ways to change the controls ourselves. In our game, we will utilize both these ways.

Swapping control schemes

Our first method will be to switch between preset control schemes. To start off, we'll add a bunch of variables that we will use for our controls:

string ControlScheme;
public KeyCode pcItem1, pcItem2, pcItem3, pcItem4, pcInv, pcPause, pcAttackUse, pcAim, xInv, xPause;

Since we can't modify the input properties, some of our controls will not be customized, such as movement, camera rotation, Xbox 360 Controller attack/use, and Xbox 360 Controller item switching. Next, we will need to set some default values to these variables; we'll modify our SetDefaultValues() function to look like this:

void SetDefaultValues()
{
  ControlScheme = "Scheme A";
  if(!isControllerConnected)
  {
    PC_Move = "WASD";
    PC_Rotate = "Mouse";
    PC_Item1 = "1";
    PC_Item2 = "2";
    PC_Item3 = "3";
    PC_Item4 = "4";
    PC_Inv = "I";
    PC_Pause = "Escape";
    PC_AttackUse = "Left Mouse Button";
    PC_Aim = "Right Mouse Button";

    pcItem1 = KeyCode.Alpha1;
    pcItem2 = KeyCode.Alpha2;
    pcItem3 = KeyCode.Alpha3;
    pcItem4 = KeyCode.Alpha4;
    pcInv = KeyCode.I;
    pcPause = KeyCode.Escape;
    pcAttackUse = KeyCode.Mouse0;
    pcAim = KeyCode.Mouse1;
  }
  else
  {
    PC_Move = "WASD";
    PC_Rotate = "Mouse";
    PC_Item1 = "1";
    PC_Item2 = "2";
    PC_Item3 = "3";
    PC_Item4 = "4";
    PC_Inv = "I";
    PC_Pause = "Escape";
    PC_AttackUse = "Left Mouse Button";
    PC_Aim = "Right Mouse Button";
    Xbox_Move = "Left Thumbstick";
    Xbox_Rotate = "Right Thumbstick";
    Xbox_Item1 = "D-Pad Up";
    Xbox_Item2 = "D-Pad Down";
    Xbox_Item3 = "D-Pad Left";
    Xbox_Item4 = "D-Pad Right";
    Xbox_Inv = "A Button";
    Xbox_Pause = "Start Button";
    Xbox_AttackUse = "Right Trigger";
    Xbox_Aim = "Left Trigger";

    pcItem1 = KeyCode.Alpha1;     
	pcItem2 = KeyCode.Alpha2;
    pcItem3 = KeyCode.Alpha3;
    pcItem4 = KeyCode.Alpha4;
    pcInv = KeyCode.I;
    pcPause = KeyCode.Escape;
    pcAttackUse = KeyCode.Mouse0;
    pcAim = KeyCode.Mouse1;
    xInv = KeyCode.I;
    xPause = KeyCode.Escape;
    }
  }

Next, we will add a function to our script that will allow the player to switch between control schemes:

void SwitchControlScheme(string Scheme)
{
  switch(Scheme)
  {
  case "Scheme A":
    SetDefaultValues();
  break;
  case "Scheme B":
    if(!isControllerConnected)
    {
      PC_Move = "WASD";
      PC_Rotate = "Mouse";
      PC_Item1 = "Numpad 1";
      PC_Item2 = "Numpad 2";
      PC_Item3 = "Numpad 3";
      PC_Item4 = "Numpad 4";
      PC_Inv = "Numpad +";
      PC_Pause = "Enter";
      PC_AttackUse = "Right Mouse Button";
      PC_Aim = "Left Mouse Button";
        
      pcItem1 = KeyCode.Keypad1;
      pcItem2 = KeyCode.Keypad2;
      pcItem3 = KeyCode.Keypad3;
      pcItem4 = KeyCode.Keypad4;
      pcInv = KeyCode.KeypadPlus;
      pcPause = KeyCode.Return;
      pcAttackUse = KeyCode.Mouse1;
      pcAim = KeyCode.Mouse0;
    }
    else
    {
      PC_Move = "WASD";
      PC_Rotate = "Mouse";
      PC_Item1 = "Numpad 1";
      PC_Item2 = "Numpad 2";
      PC_Item3 = "Numpad 3";
      PC_Item4 = "Numpad 4";
      PC_Inv = "Numpad +";
      PC_Pause = "Enter";
      PC_AttackUse = "Right Mouse Button";
      PC_Aim = "Left Mouse Button";
      Xbox_Move = "Left Thumbstick";
      Xbox_Rotate = "Right Thumbstick";
      Xbox_Item1 = "D-Pad Up";
      Xbox_Item2 = "D-Pad Down";
      Xbox_Item3 = "D-Pad Left";
      Xbox_Item4 = "D-Pad Right";
      Xbox_Inv = "B Button";
      Xbox_Pause = "Back Button";
      Xbox_AttackUse = "Right Trigger";
      Xbox_Aim = "Left Trigger";
        
      pcItem1 = KeyCode.Keypad1;
      pcItem2 = KeyCode.Keypad2;
      pcItem3 = KeyCode.Keypad3;
      pcItem4 = KeyCode.Keypad4;
      pcInv = KeyCode.KeypadPlus;
      pcPause = KeyCode.Return;
      pcAttackUse = KeyCode.Mouse1;
      pcAim = KeyCode.Mouse0;
      xInv = KeyCode.JoystickButton1;
      xPause = KeyCode.JoystickButton6;
    }
  break;
  }
}

As you can see, this function is very similar to our SetDefaultValues() function; it acts the same way. SwitchControlScheme() takes a string that determines which control scheme to use and then assigns the appropriate data. The first scheme is the default control scheme, while the other one is a new scheme. The new scheme changes the following:

Item keys are now on the keypad
Inventory buttons are now the + key and B key
Attack/use inputs are switched on the mouse
Pause has been changed to the Enter key and the Backspace key

Adding a control switch button to the GUI

Lastly, we'll need to add a GUI button to our OnGUI function to allow the player to switch control schemes. Add the following before the line that ends the group:

GUI.Label(new Rect(15, 345, 125, 20), "Current Control Scheme");
if(GUI.Button(new Rect(25, 370, 135, 20), ControlScheme))
{
  if(ControlScheme == "Scheme A")
  {
    SwitchControlScheme("B");
    ControlScheme = "Scheme B";
  }
  else
  {
    SwitchControlScheme("A");
    ControlScheme = "Scheme A";
  }
}

This button, when clicked, will call the SwitchControlScheme() function and pass it a letter determining the control scheme being used.

Cycling control inputs

Our next method of customization will let the player click on one of the GUI buttons in our controls, and pick another control to switch it. To start off, we'll add variables that we'll use to hold the original values of our controls. The last two variables will be used to allow us to customize our controls:

private KeyCode orig_pcItem1, orig_pcItem2, orig_pcItem3, orig_pcItem4, orig_pcInv, orig_pcPause, orig_xInv, orig_xPause;
bool ShowPopup = false;
KeyCode PreviousKey;

In the SetDefaultValues function, assign these variables to our previous control variables in both the if and else statements:

orig_pcItem1 = pcItem1;
orig_pcItem2 = pcItem2;
orig_pcItem3 = pcItem3;
orig_pcItem4 = pcItem4;
orig_pcInv = pcInv;
orig_pcPause = pcPause;

Assign the Xbox 360 Controller controls in the else statement:

orig_xInv = xInv;
orig_xPause = xPause;

Next, we are going to add a function that we'll call to switch our keys:

void SetNewKey(KeyCode KeyToSet, KeyCode SetTo)
{
  switch(KeyToSet)
  {
  case KeyCode.Alpha1:
    pcItem1 = SetTo;
    PC_Item1 = SetString(pcItem1.ToString());
    break;
  case KeyCode.Alpha2:
    pcItem2 = SetTo;
    PC_Item2 = SetString(pcItem2.ToString());
    break;
  case KeyCode.Alpha3:
    pcItem3 = SetTo;
    PC_Item3 = SetString(pcItem3.ToString());
    break;
  case KeyCode.Alpha4:
    pcItem4 = SetTo;
    PC_Item4 = SetString(pcItem4.ToString());
    break;
  case KeyCode.I:
    pcInv = SetTo;
    PC_Inv = SetString(pcInv.ToString());
    break;
  case KeyCode.Escape:
    pcPause = SetTo;
    PC_Pause = SetString(pcPause.ToString());
    break;
  case KeyCode.JoystickButton1:
    xInv = SetTo;
    Xbox_Inv = SetString(xInv.ToString());
    break;
  case KeyCode.JoystickButton6:
    xPause = SetTo;
    Xbox_Pause = SetString(xPause.ToString());
    break;
  }
}

This new function takes in two properties: the first one will be what KeyCode we set and the second one will be what KeyCode we are setting the key to. You can see that we also set our string variables, which are used in the GUI with another function. We'll create that function now:

string SetString(string SetTo)
{
  switch(SetTo)
  {
  case "Alpha1":
    SetTo = "1";
    break;
  case "Alpha2":
    SetTo = "2";
    break;
  case "Alpha3":
    SetTo = "3";
    break;
  case "Alpha4":
    SetTo = "4";
    break;
  case "Return":
    SetTo = "Enter";
    break;
  case "Escape":
    SetTo = "Escape";
    break;
  case "I":
    SetTo = "I";
    break;
  case "JoystickButton6":
    SetTo = "Start Button";
    break;
  case "JoystickButton1":
    SetTo = "A Button";
    break;
  }
  return SetTo;
}

Now in our OnGUI function, we'll need to adjust some of our code. Before we start our controls group, we will check whether our controls pop up is activated. Add the if statement to our code and encapsulate the Controls Group:

if(!ShowPopup)
{

Next, we'll edit some of our GUI buttons to allow customization. Start with the PC_Item1 button and change it to this code:

if(GUI.Button(new Rect(150, 125, 135, 20), PC_Item1))
{
  ShowPopup = true;
  PreviousKey = pcItem1;
}

Do the same thing for the following buttons:

PC_Item2
PC_Item3
PC_Item4
PC_Pause
PC_Inv
Xbox_Inv
Xbox_Pause

Set ShowPopup to true and PreviousKey to its expected value, accordingly, such as pcItem2, pcItem3, pcItem4, and so on. Place a closing bracket afterwards to close the if statement that we created earlier.

Adding the controls pop up to the GUI

It's time to add our controls pop up to the GUI. This is where the player will select what control to swap. To do this, we will add an else statement, extending our if statement, to create the pop up:

else
{
  GUI.BeginGroup(new Rect(Screen.width/2 - 300, Screen.height / 2 - 300, 600, 400));
  GUI.Box(new Rect(0,0,600,400), "Pick A Control to Switch");
  if(GUI.Button(new Rect(150, 125, 135, 20), "1"))
  {
    SetNewKey(PreviousKey, orig_pcItem1);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(150, 150, 135, 20), "2"))
  {
    SetNewKey(PreviousKey, orig_pcItem2);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(150, 175, 135, 20), "3"))
  {
    SetNewKey(PreviousKey, orig_pcItem3);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(150, 200, 135, 20), "4"))
  {
    SetNewKey(PreviousKey, orig_pcItem4);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(150, 225, 135, 20), "I"))
  {
    SetNewKey(PreviousKey, orig_pcInv);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(150, 250, 135, 20), "Escape"))
  {
    SetNewKey(PreviousKey, orig_pcPause);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(325, 225, 135, 20), "A Button"))
  {
    SetNewKey(PreviousKey, orig_xInv);
    ShowPopup = false;
  }
  if(GUI.Button(new Rect(325, 250, 135, 20), "Start Button"))
  {
    SetNewKey(PreviousKey, orig_xPause);
    ShowPopup = false;
  }
  GUI.EndGroup();
}

When the player clicks on one of these new buttons, the SetNewKey function is called. When called, we pass PreviousKey, which is the key the player is customizing, as well as the key they select, which is the new value of PreviousKey. This is a great and simple way to change controls, which makes it simple for the player.

Resetting the controls

In this section, we will add the ability to allow the player to reset the controls to their default values.

Adding the Reset function

The reset function will use our SetDefaultValues() function as well as reset a couple of our other variables:

void Reset()
{
  SetDefaultValues();
  ShowPopup = false;
  PreviousKey = KeyCode.None;
}

Here, we call our SetDefaultValues() function, and then reset some other variables. Resetting the ShowPopup Boolean and our PreviousKey KeyCode will ensure that everything related to customization of controls has been reset.

Adding the Reset input

Now, we'll make a GUI button that will call the Reset function. Add this just before the line of code that ends the GUI group in the OnGUI() function's if statement:

if(GUI.Button(new Rect(230, 370, 135, 20), "Reset Controls"))
{
  Reset();
}

When the player clicks on this button, the controls will be set to their default values. Here is the finished product of the script that you just created:

Filter reviews by

All

Amazon verified reviews

MR B BYFORD Feb 16, 2015

Hugely useful overview of various game design has its and how they can work in unity.Got this after the 2d game development in unity book, and was please at how it built on my knowledge and didn't spell things that I already knew. Not for absolute beginners.

Amazon Verified review

Mário Freitas Mar 01, 2015

The book is written in very concise and simple to understand way, guiding the reader the whole way to actually create a simple working game, and covering most topics on game development scripting.I would highly recommend this book to people who are new to Unity scripting and to those who would like to learn more about how to structurally and conceptually organize a game from the point of view of game development scripting.The book also offers standard approaches to the implementation of features that are present and required in any game.

Peter Matthew Apr 30, 2015

As a Lecturer in Games Development I am always on the lookout for books that can help my students improve their understanding of both c# and Unity3d. This book provides a lot of very good tutorials and explanations that cover a variety of subjects within the games development area. The sections are clearly written and provides good examples of the code being discussed. After discussing the book with some of my second year students they described it as “very helpful” and “easier to understand than a lot of other books”.Some criticisms of the book are that the sections are a little abstract in places jumping from topic to topic and it relies on a previous understanding of coding knowledge to get the most out of it, therefore lending itself more to an intermediate or advanced user.Regardless the author does an excellent job of explaining useful scripts that most games developers will want to include: such as re -bindable controller settings and user interface development, therefore providing the reader with a practical set of scripting examples.I would recommend this book for anyone wanting to improve their understanding of Unity scripting and my department is now using this book as part of our essential reading list for all second year games programmers.

Robert L. Dixon Feb 07, 2015

I read a lot of books about Unity and C# since I'm always trying to up my game, so to speak. This book has some good sections but overall doesn't cohere as well as it could. But it could be useful for people with some Unity experience who are looking for specific techniques.It jumps right into scripting individual subsystems without talking about what kind of game is going to be built and how everything will fit together. Later on you learn the example game is an RPG-style game with characters, weapons and objects. It would have been nice to know this ahead of time, because some of the chapters are only relevant to this type of game.Overall this is more like a "cookbook" of various recipes, as opposed to a step-by-step guide to building a real game. If you already have some experience coding C# in Unity, and you are interested in some of the chapter topics, you should find the book useful.Here's a brief rundown on some specific chapters:* The first chapter on Interactive Input present a nice technique for switching among input control schemes. However there's an emphasis on supporting the XBox 360 controller which might not be relevant to a lot of developers.* The GUI chapter relies a little too heavily on the old, mostly obsolete Unity GUI approach, so it is not too useful in the post-Unity-4.6 world.* The Expandable Item Classes chapter presents a nice starting point for structuring in-game items that affect player characters and objects.* The chapter on AI covers two different AI topics: simple enemy decision-making (switching an enemy object among Idle, Guard, Combat, Flee states), and pathfinding. The pathfinding section gives a good introduction to Unity's NavMesh system, which is not covered in many other books. The example for this chapter uses the AI scripts to animate some freely-available skeleton models (from the Asset Store) around an environment.* The chapter about Keeping Score on the other hand presents some real brute-force coding with hard-coded achievement thresholds and such. There are better and simpler ways to code this, so I would give this chapter a pass.* The same could be said for the next chapter, which covers Saving and Loading Data. It uses XML, which is generally heavier and harder to work with than JSON, and again shows some brute-force coding that might not hold up well over time.* Chapter 8 deals with audio and offers some simple, reusable classes for managing and playing sounds.* The final chapter, "Putting It All Together," builds a simple game by assembling all the subsystems from previous chapters. It's very nice to see all the parts working together at the end. This chapter could have been fleshed out a bit more. It would have been nice to have an overview, like a diagram, of how all the subsystems fit together, rather than a step-by-step "now add this, now add this" sequence. In fact this kind of overview would have been really useful prior to Chapter 1, so the reader can go into the rest of the book knowing what to expect.Overall there are a lot of things to learn from this book. In addition there is a nice emphasis on play-testing at the end of each chapter, with suggestions of ways to enhance the examples in your own games. But it's not a complete guide to building your own games in Unity.

Matthew Feb 09, 2015

Bottom line up front, this book is a great tool to keep in your kit bag. With a basic knowledge of programming and Unity, I started an indie game development company with several game ideas in mind. What I quickly discovered was, like most things in life, there are multiple ways to accomplish a single task within Unity. This created a challenge I hadn’t planned for. Originally I thought it would be difficult to find the right literature to help me achieve my goal, but instead I found that I was inundated with information. I recently came across “Unity Game Development Scripting” by Kyle D'Aoust and became quite pleased with what I had found. The book is laid out in a very efficient manner covering all the major aspects of creating a game. The first chapter deals with the most important aspect, defining user input. It lays out two options one for keyboards and the other for an Xbox controller. At first glance the reader may be tempted to think this doesn’t apply to me because I’m not developing for those platforms. This may be true, but if the reader looks deeper they will start to see how the techniques used in the book can transfer into other projects. The process the writer took to define different aspects and requirements for control are useful when designing the controls for all games. Chapters 5 and 7 are also great examples of a situation where the techniques used are beneficial to any reader attempting to develop a game in Unity. I have personally struggled with scripting enemy artificial intelligence in a 2D platformer game and have waffled between different techniques. After reading chapter 5, I was able to add a more efficient solution to my games even though the writer is referencing 3D game creation. In addition, chapter 7 answers the question of saving game progress. When I first started developing games this task perplexed me, but “Unity Game Development Scripting” by Kyle D'Aoust does an excellent job of defining C# scripting that accomplishes the task. Though I was overall happy with this book, there was one point of contention I had with the way it was written. The author provides numerous coding examples written in C# throughout each chapter. He does a good job giving a description after each block of coding, but I found it to be rather taxing on the mind to connect the explanations with the code previously read. A better way to accomplish this would have been to add comments directly into the code itself. This would have personally helped me better follow the readings. Again, this book is an excellent tool for any developer to have. If you don’t have an intermediate understanding of programming and Unity, you will probably find this book to be frustrating as it is not a tutorial based piece of work. But if you are looking for a resource to help refine and/or add to your own techniques for game development then this is the right place to start.

Unity Game Development Scripting: Write efficient C# scripts to create modular key game elements that are usable for any kind of Unity project

What do you get with eBook?

Mapping the needed controls

Checking the input manager

Checking the Xbox 360 Controller inputs

Adding additional controller inputs

Adding a start button and trigger inputs

Adding directional pad inputs

Adding PC control inputs

Description

Product Details

What do you get with eBook?

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs