I want you to create one script that will be attached to two GameObjects. The script will have two methods that will cause the GameObjects to rotate left and right. This will show you that from a single script file, two separate Component objects will be created in the memory. Each Component object is a separate instance object with no absolutely knowledge of the other.
- In your Scene, create two GameObjects,
CapsuleandCube. - Add a Directional Light to the Scene so you can easily see the GameObjects.
- Here's my Scene as an example:
- Create a new C# Script and name it Spinner.
- Code the script as shown in the following screenshot:
- Attach the
Spinnerscript to the Capsule and the Cube GameObjects. - Modify
LeaningScriptas shown in the following screenshot:
- Save the file.
- In Unity, click on Play.
Here's the output to the Console:
Now press the left and right arrow keys to make the Capsule spin, and the up and down arrow keys to make the Cube spin.
You created one script named Spinner, then attached the script to two separate GameObjects. When you click on Play, two separate Spinner Component objects are created in the computer memory. This is an example of how the Spinner class is just a blueprint, a description, of what each Component object created will be.
To access each Spinner Component from the LearningScript Component, you need to know about each GameObject that the Spinner Component is attached to.
Note
This code is just a simple demonstration to show how Dot Syntax works. In real life, you may have each Component detect user input. On the other hand, perhaps you may want a class dedicated to processing user input. That's the neat thing about writing code, there are a zillion ways to accomplish a task.
An analysis of the code shown in the previous code screenshot is as follows:
On LearningScript:
Line 6: GameObject capsuleGO;
Line 7: Spinner cubeComp;
- A variable of type
Spinneris declared - The value this will store is a reference to a
SpinnerComponent object created from theSpinnerclass
Line 9: void Start()
- The
Start()method is used to allow the two variables to be initialized - Remember, this method is called only once
Line 11: capsuleGO = GameObject.Find("Capsule");
- The
Find()method of theGameObjectclass locates a GameObject in our Scene - The reference to the Capsule GameObject is assigned to the variable
capsuleGO - This is item 5 in the previous graphic and also on the previous code screenshot
Line 12: Debug.Log(capsuleGO);
- This line was added just to show that the Capsule GameObject is in fact referenced in the variable
capsuleGO
Line 13: cubeComp = GameObject.Find("Cube").GetComponent<Spinner>();
Line 14: Debug.Log(cubeComp);
- This line was added just to show that the
SpinnerComponent is part of the Cube GameObject, and is in fact referenced in the variablecubeComp
Line 19: if(Input.GetKey(KeyCode.LeftArrow)
- This
ifstatement checks to see if the user has pressed the left arrow key - If pressed, Line 21 of the code block is executed
Line 21: capsuleGO.GetComponent<Spinner>().SpinLeft();
- This line shows using Dot Syntax to locate a method in a Component of another GameObject.
- The
CapsuleGOvariable substitutes the reference to the Capsule GameObject - The
SpinnerComponent object is located on the Capsule GameObject - The
SpinLeft()method is called in theSpinnerComponent of the Capsule GameObject - Code flow now jumps to the
SpinnerComponent object
Spinner (on the Capsule):
Line 6: public void SpinLeft()
- This is the
SpinLeft()method called from theLearningScriptobject - Line 8 in the code block is executed
Line 8: transform.Rotate(0, 0, 60 * Time.deltaTime);
- The
Rotate()method on theTransformComponent object is called which causes the Capsule to spin around the z-axis - Notice though, that the variable named
transformis used in the Dot Syntax statement instead of theGetComponent<Transform>()method - Unity has several built-in Components, such as the
TransformComponent class - Find the
GameObjectclass in the Scripting Reference and notice that one of the variables is namedtransform - Instead of having to use the
GetComponent()method on a GameObject, Unity has provided a convenient variable already assigned the value of theTransformComponent - The following screenshot shows the
transformvariable described in the Scripting Reference:
- The
Rotate()method shows 3 arguments being sent to the method. - In this example, the Capsule is rotating 60 degrees per second on the z-axis.
- Code flow now returns to the
LearningScriptobject.
Line 24: if(Input.GetKey(KeyCode.RightArrow)
- This
ifstatement checks if the user has pressed the right arrow key - If pressed, line 26 of the code block is executed
Line 26: capsuleGO.GetComponent<Spinner>().SpinRight();
Line 29: if(Input.GetKey(KeyCode.UpArrow)
- This
ifstatement checks if the user has pressed the up arrow key - If pressed, line 31 of the code block is executed
Line 31: cubeComp.SpinLeft();
- This is different than lines 21 and 26
- Refer back to line 13. The
cubeCompvariable already stores the reference to the Cube GameObject and theSpinnerComponent object, thereforeJust the variablecubeCompis needed in the Dot Syntax to call theSpinLeft()method on the Cube GameObject - Code flow is similar to line 8, except that the Cube rotates now
Line 34: if(Input.GetKey(KeyCode.DownArrow)
- This
ifstatement checks to see if the user has pressed the down arrow key - If pressed, line 36 of the code block is executed, spinning the Cube right
In LearningScript, lines 21 and 31 perform the same functionality of calling the SpinLeft() method on their Spinner Components. Yet the code on each line is very different. The difference is that cubeComp already stores a reference to the Cube's Spinner Component. There is no capsuleComp variable to store a reference to the Capsule's Spinner Component.
Try creating a capsuleComp variable and store a reference to the Capsule's Spinner Component. Then change lines 21 and 26 to use capsuleComp.