Okay, let's get started with your first script. 
You'll see that there is some code already there. 
This is a template to make it easier to get started writing Unity scripts. 
A function is a way to group code under one name. 
There are two functions included in the script template, Start and Update. 
You can use the function name as a shorthand, or call the function instead of writing the same code every time. 
The code in Start is called when your game starts, and the code in Update is called once per frame of your game. 
You won't actually need the Update function in this script, so remove that code for now. 
Before you begin writing code, let's think for a moment. 
What do you need to do with the script? 
The script needs to check every frame for player input and then apply that to the player GameObject every frame as movement. 
Where will it check for the movement? 
The Input System has a method you can use to get the data from this input. 
Where will it apply the movement? 
There are two things you can use to apply this, Update and Fixed Update. 
Update is called before rendering a frame, and this is where most of your code will go. 
Fixed Update, on the other hand, is called just before performing any physics calculations, and this is where your physics code will go. 
You will be moving the ball by applying forces to its Rigidbody. 
This is physics, so you will put this part of the code in Fixed Update. 
Okay, let's get started. 
Because you are using the Input System, you need to add its namespace to the script. 
Namespaces are a collection of classes and other data types which can be imported at the start of your scripts. 
There are already three namespaces used in the template, System.Collections, System.Collections.Generic, and UnityEngine. 
There are lots of different namespaces. 
The additional one you need for this script is the InputSystem namespace. 
Add a new line below the first three namespaces. 
Write using UnityEngine .InputSystem; 
This will enable you to access the code and functions in the InputSystem namespace in this script. 
The PlayerInput component will notify the PlayerController script of action happening by calling functions with pre-defined names within your scripts. 
For example, to create the Roll-a-Ball game, you need to be notified whenever the move action happens. 
The predefined function for the changes in movement controls when pressing WASD or moving a joystick on a controller is called OnMove. 
In that function, the computer will read the value of the input, for example, up, down, left, or right, and then use that information to move the ball using code in the Update function, which you'll write later. 
Let's write an OnMove function. 
The first thing you need to do is write a function declaration, which tells the computer to create a function. 
Below the start function but before the final curly brace, add a new line. 
Write void OnMove, open and closed brackets. 
Void means that this function won't return any values. 
Next, add an open curly brace, leave a line, and then add a closed curly brace. 
The space inside the braces is called the function body, and this is where you add instructions for the computer to complete. 
These instructions are specifically for the function OnMove. 
Each function has its own set of curly braces. 
Okay, what's next? 
The PlayerInput component will be sending data of type input value to your script, so you need to add this to the function's input parameters. 
These are variables which will be used to store and reference data for the function. 
Inside the parenthesis, in your function call, add InputValue movementValue. movementValue is the name of the variable you will use within the function. 
InputValue is the type of variable. 
Variables can have different data types, which means they store different types of data. 
The movement of the Roll-a-Ball sphere will be captured in two directions, up and down and left and right. 
In other words, the MovementValue variable will capture and store the data from the X direction and the Y direction of input devices. 
This kind of data can be stored as a Vector2 variable. 
In the next video, you'll create that variable and then start to apply the data to the player sphere.