Tag

Game Development Archives - Selfloop

Understanding “Vector” in Unity

By | Unity3D | No Comments

Definition:  In unity, Vector is the data type where you can do all types of vector calculation (Dot product, Cross product, Normalize, Projection, Magnitude) and other unity given function such as “Distance” & “MoveTowards” etc. As the “Distance” and “MoveTowards” are highly used in our “Game Development” process. We will try to describe as much as possible down below.

 

  • Distance: It calculate the distance between 2 vector point. We usually use it for detection or creating a sensor like a game object will react when the user comes to a certain point.

Parameter:         Vector2.Distance(Vector2.position, Vector2.position)

Vector3.Distance(Vector3.position, Vector3.position).

 

Vector (1)

Here, the “Mine” will be explode when the distance between the “Player” & “Mine” will be less than or equal to “3.14”. As the “Player” is at “5.14” distance, so the “Mine” is not exploding. We can see the following script for more detail.


  • MoveTowards: It basically moves the current position of the game object to the targeted position based on the velocity that has been assigned in the “MoveTowards” function parameter.

Parameter:

Vector2.MoveTowards(Vector2.position (Current), Vector2.position (Target), Velocity).

Vector3.MoveTowards(Vector3.position (Current), Vector3.position (Target), Velocity).

               

Problem: Let us consider that we have a homing missile that chases the player. If the player is within its range, It will start chasing the player. Let’s see the following script reference.

 

 


# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera

Understanding “Sprite Renderer” Component

By | Unity3D | No Comments

Definition: “Sprite Renderer” component is responsible for rendering Image/Sprites in 2D/3D game mode.

Sprite Renderer (0)

Let us consider you want to add a simple background to you level. All you have to do is to select a “Game Object” -> Go to “Inspector View” -> Click on the “Add Component” -> “Sprite Renderer”, and select the Image/Sprite from the “Sprite” section to displayed in the game level. You can also create a “Game Object” by right clicking in the “Hierarchy” -> “2D Object” -> Sprite.


Components: Here, we are going to learn about the sub-components of the “Sprite Renderer”.

  1. Sprite: Here, you will be able to select the “Image/Sprite” that you want to be displayed in your game level.

Sprite Renderer (1)

 

Problem: Let us consider you want to change the Image from one image to another when you pressed the “S” key.


  1. Color: By using the color, you will be able to cast a “Gradient/Shade” on your selected “Image/Sprite”. By default the color is set to white (r: g: b = 255 : 255 : 255). Let us consider the following difference between 2 sprites.

Sprite Renderer (2)

Problem: Let us consider we want to change the opacity to its half when the user pressed the “O” key from keyboard. Note that


  1. Flip: By using this sub-component, you will able to flip the image along with the X/Y-Axis. By default, let us consider your image is facing to the right side. When you flip it along the X-axis, the image will now face to left. Let’s see the following image for better understanding.

Sprite Renderer (3)

Problem: Let us consider we want to flip “Sparty” (Character) to left face when we click on the “Left Arrow Key”. As by default Sparty is facing to the right.

 


  1. Materiel: Here you can also use different custom materiel for giving different gradient on the following image. We will talk more about in “Understanding “Materiel”” section.
  2. Sorting Layer: it defines the order that which layer would be render over another layer. Let us consider that the “Sparty” waking alongside of a tree. Is the tree will be behind him when he pass? Or the tree will hide “Sparty” when he goes over?
  • Let’s select the “Sparty” from the “Hierarchy”.
  • We can see that the “Sorting Layer” is set to default. (Cause it’s the default sorting layer)
  • Let’s click on the dropdown section and click on the “Add Sorting Layer”.

Sprite Renderer (4)

  • As we can see that our “Inspector View” has changed, and showing the “Sorting Layer”. We can also see that “Unity” has already created the “Default” (Unchangeable) sorting layer which we saw in the “Sprite Renderer” of “Sparty” game object.

Sprite Renderer (5)

  • Let’s create a “Sorting Layer”, naming “Player” layer.

Sprite Renderer (6)

  • Now set the “Player” layer to “Sparty”.

Sprite Renderer (7)

  • Now as we can see that the “Sparty” is now rendering over the “Tree”. Because the “Sparty” is set to the “Player” layer, where as the “Tree” has set to “Default” layer.

Sprite Renderer (8)

  • You should remember that the “Layer” which is the last “Layer” of the list has the highest priority for rendering to the top of the other layer.

  1. Order in Layer: Let us consider there are 2 different images in the same “Default” layer, where both of the images are in the same position. Now the question is, which image would be at the top to render? This is where the “Order in Layer” comes in. The “Sprite” that has the highest number in the “Order in Layer” would be render on the top. Rest of the object will be rendered as following.

Sprite Renderer (9)


# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera

 

Understanding “.unityPackage”

By | Unity3D | No Comments

Definition: Unity package is nothing but “.zip” format for the unity where you can directly “zip” and “unzip” your following game asset from the editor. Let us consider the fact that your friend sends you willing to send you a 100 sprites of enemy along with the script. He will just create those asset to “.unityPackage” and send that file to you which will be extract to your “Asset” folder which is displayed as a “Project” view in the “Unity Editor”.

We will show you how you can create and extract a “.unityPackage” in “Unity Editor”.

 

Export Package:

  1. Let us consider that we want to create our “Art” folder from “Project” view to a “.unityPackage”. I will show you the both way on how you can export a “.unityPackage”.

unityPackage (1)


  1. You can either “Select” the folder that you want to export, and “Right Click” on it. Where you can find an option call “Export Package..”.

unityPackage (2)


  1. Here, you can see that all the items are the “Art” folder has been selected to be exported in the “.unityPackage”. you can deselect any item if you wish not to be include in the “.unityPackage”. Now let’s create the “Export” button to export our art asset.

unityPackage (3)


  1. It will ask you to set a destination where it will export the “.unityPackage”. give your package a name and click on the “Save” button.

unityPackage (4)


  1. As you can see, that my “ArtAsset.unityPackage” is now ready to port on any unity game.

unityPackage (5)


Import Package:

 

  1. Let us consider that we want import the “ArtAsset.unityPackage” to our new project in unity. To do that, just create a new project in unity. ( I am skiping this section as I do believe you guys can create a project in unity).
  2. Now go to the “Assets” -> “Import Package” -> “Custom Package..”.

unityPackage (6)


  1. Now select your “ArtAsset.unityPackage” and click “Open” button.

unityPackage (7)


  1. Now it will show you the list of all the content of the following package, where you can select/deselect any items you wish to add, and what are the items that are new in your project (the reason why it’s showing “NEW” it’s because the following item is not in the “Asset” folder, if it doesn’t show “NEW” means, the item that you want to add is already in the “Asset” folder. By importing again, it will just override the file). Now, let’s click on the “Import” button to import all the asset to our “Project View” in “Unity Editor”.

unityPackage (8)

 

  1. It will take few seconds (Based on the asset size) to load all the item of the “.unityPackage”. Here you can see in our “Project View” that all the asset has been loaded successfully.

unityPackage (9)


# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera

Understanding “Tag” in “Unity”

By | Unity3D | No Comments

Definition: Tag is basically grouping the different types of game object by assigning them with a name.

For example, let us consider that there are 2 types of enemies such as “square” and “circle”. When the player collided with any of those enemy, the player will die. So far that I have taught you guys, you might be thinking to type your codes like this,

void OnCollisionEnter(Collision other) {

if(other.gameObject.name == “square” || other.gameObject.name == “circle”){

Destroy(gameObject);

}

}

But what if, there are 20 types of enemy in your game, so are you going to type their every single name to your code? And what if there are 20 “circle” enemy in the game, where their naming comes to “circle (1), circle (2) …..” by copying in unity. So are you going to type all of their name through your code? Definitely not, this is where the tagging comes. We are going to create an “Enemy” tag from the “Tag” window in “Unity” and set that “Enemy” tag to our different type of “Enemy” game object. Let’s see how we can create and use tags on unity on the following steps.

 

  1. To create those tag, lets select a “Game Object”.

Tag (1)

  1. Here, as we selected “Enemy (6)” from the “Hierarchy”. As now we can see that the “Tag” is now set with “Untagged” means, that there is no tag for the following “Game Object”. Let’s click on the drop down menu of the “Tag”.

Tag (2)

Now “Click” on the “Add Tag…” section to creating a “tag” for the following “Game Object”.

  1. Now you can see that the following “Inspector View” has changed to “Tags & Layer” section.

Tag (3)

As we don’t have any “Tags” right now, so the following list is showing “List is Empty”. Let’s click on the small “+” (Add) sign icon to create our first tag.

 

  1. Let’s set our new tag name as “Enemy”, and click on the “Save” button.

Tag (4)

  1. Now we can see that the “Enemy” tag is now available on the “Tags” list.

Tag (5)

  1. Again, let’s select the “Enemy (6) from the “Hierarchy” and click on the dropdown menu of “Tags” to select the “Enemy” tag for our enemies.

Tag (6)

  1. After selecting the “Enemy” tag, it is now been displayed on the “Tag” section of the “Inspector View”.

Tag (7)

  1. As now we have set the enemies with the “Enemy” tag, we can write our code in something like this,

void OnCollisionEnter(Collision other) {  if(other.gameObject.tag == “Enemy”){         Destroy(gameObject);    }}

Where this script will now destroy the player (assuming this script is attached to “Player”) as it touches with any object containing “Enemy” tag.

 


# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera

 

 

Understanding : “Input” from Keyboard

By | Unity3D | No Comments

Definition: The “Input” class in unity is responsible for taking all kinds of input from difference devices. For windows, linux & Mac, we use “Input.GetKeyDown”, “Input.GetKey”,  “Input.GetKeyUp”, “Input.GetMouseButtonDown”, “Input.GetMouseButton”, “Input.GetMouseButtonUp” , “Input.mousePosition” & etc. Here, we will talk about more about how we can take input from the keyboard.

  • Input.GetKeyDown: The first frame/instance when user start pressing the key from keyboard. The return type of this function is true/false.

GetKeyDown

Let us see the following picture, Here the “GetButtonDown/GetKeyDown” Is set to true when the user is pressing the button. We will talk about more about why ““GetButton/GetKey” is also true. Here is a simple example to make player jump.

If(Input.GetKeyDown(KeyCode.Space)){

_rigidbody2D.AddForce(0.0f,500.0f);

}

  • Input.GetKey: Return true while the user is pressed and holding down the key. Here as you can see the “GetKeyDown/GetButtonDown” is false while the “GetKey/GetButton” is true. The reason why “GetButton” is true because it returns true while the user press and hold down the key where “GetButtonDown” take only the input from the first frame/instance.

GetKeyLet us consider you want to move your player to the right while your pressing and holding down your “RIGHT_ARROW_KEY”. The following code could be an example of the scenario.

If(Input.GetKey (KeyCode.RightArrow)){

            _rigidbody2D.velocity(2.0f,0.0f);

}

 

  • Input.GetKeyUp: It return true when user release the key s/he was pressing.

 GetKeyUp

Let us consider the scenario that a player is using his jet pack. By releasing the “UP_ARROW_KEY”, we want the jetpack not to go further to the top direction. To do that, we want to make the velocity over the Y-Axis to “0”, so the gravity can instantly start dragging him to the negative Y-Axis.


# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera

Understanding : Rigidbody2D component

By | Unity3D | No Comments

Definition: Rigidbody2D is a component that activate the game object under the unity physics engine. So by adding the Rigidbody2D, the game object get pulls by gravity, start having collision etc. When you attached the Rigidbody2D component it overrides the transform component for position and rotation. So it is better to do the translation and rotation from “Rigidbody2D” when it is attached with the following game object.

  • Body Type:

 Rigidbody2D

There are basically 3 types of “Body Type”,

These three types of body have effect on movement and collision detection mechanism.

Dynamic: Dynamic body type is the most performance expensive body type of the rigidbody2D as it is effected by all the behavior of the physics such as collision detection, mass and specially dealing with the gravity and force. So if any game object would like to have the most realistic physics mechanism, “Dynamic” body type is the way to go.

 

Kinematic: Kinematic body type is more processor efficient as it doesn’t effect by the gravity and force, where it still can detect the collision. The outer force cannot have any impact as the game object itself assigned an infinite mass to itself. But you can defiantly move & rotate these types of game object by Rigidbody2D.MovePosition & Rigidbody2D.MoveRotation.

Use Full Kinematic: When enabling this setting, it will detect the collision with other body type as well (Dynamic, Static: Same collision detection mechanism as Dynamic). The only difference with “Dynamic” body type that it has infinite amount of mass that cannot be effect by gravity or force.

 

Static: Static body is the least processor cost physics behavior as it also has infinite mass assigned to itself. So basically, a boss that cannot be knock back can be an example of the static behavior.

  • Material: We have talked about the material on the “Collider2D” component section, please check the following link for more information.
  • Simulated: Its basically enabling/disabling the physics behavior (Including Rigidbody2D, collider2D join2D) of the game object rather than enabling/disabling each of the component individually. Its more memory efficient than disabling every collider2D individually as creating and destroying a behavior is memory expensive.
  • Use Auto Mass: Auto mass calculate the mass of the game object by the size of the collider. Let us consider the “BoxCollider2D”. Here the size is denoted by (X,Y). So the mass that would be generate by auto mass = X * Y (3 x 2 = 6 mass).
  • Linear Drag: It is basically the friction of the velocity over the X & Y axis. The higher the value, the higher the friction for the velocity.
  • Angular Drag: It is basically the friction of the rotation over the X & Y axis. The lower the value, the higher the rotation by the environmental force or collision.
  • Gravity Scale: it is the coefficient of the gravity that how strong the gravity would be over the game object. If the gravity scale is “2.5”, so the gravity would 2.5x (9.8 x 2.5 = 24.5ms^-2) stronger.
  • Collision Detection: it is basically how frequently the collision will detect. There are two ways of setting that a collision can be detected.
  1. Discrete: It basically check the collision over the physics update. Physics update are basically the “FixedUpdate()” that we used in the script. This update happens after fixed period of time. Like in every 0.2sec, the physics engine will start detecting collision.
  2. Continuous: It basically check the collision on every update. The “Update()” method gets called in a random interval of time based on how much process it has to do for generating the next frame. The call of this update are not after a fixed amount of time. For example, the next 4 frame can be load -> 0.025, 0.033, 0.0.75, 0.9. So it is more efficient when the collision detection is sensitive for any game object (Could be player?).
  • Sleeping Mode: there are 3 types of sleeping mode.
  1. Never Sleep: You should not choose this mode as it can hamper the resource optimization.
  2. Start Awake: The game object can start detecting collision from “Awake()” stage.
  3. Start Asleep: The game object will initially sleep, but will be awake by the first collision detection.
  • Constraint: It is useful to freeze the rotation over the Axis.

 

Methods: Some of the methods that we frequently use in game rigidbody2D,

  1. Rigidbody2D.AddForce.
  2. Rigidbody2D.Velocity.

 

  • Rigidbody2D.AddForce(): The parameter of the “AddForce” is a Vector2, that denotes in which direction the force is going to apply and how much force it is going to apply to that certain direction. Let us consider, we want to apply force to the positive Y-Axis to make the player jump by pressing the “Space” key from the keyboard. For that, we will write the following code,

If(Input.GetKeyDown(KeyCode.Space)){

//_rigidbody2D is holding the reference of the Rigidbody2D component of

// attached game object.

_rigidbody2D.AddForce(new Vector2(0.0f , 500.0f));

}

Here “500” is the amount of force we want to apply to a certain direction, and the value is positive cause we want to apply the force to the positive Y-Axis.

 

  • Rigidbody2D.Velocity(): The parameter of the “Velocity” is also Vector2, that denotes in which direction we want to apply our velocity and how much velocity we want to apply to that specific direction. Remember, the velocity is the result of the force. When you are changing the velocity it means the space is putting the force to that certain direction on your game object. Let us consider we want to move the character to the right side by pressing the “Right Arrow Key”. So changing the velocity over the positive X-Axis will do our trick.

If(Input.GetKeyDown(KeyCode.RightArrow)){

//_rigidbody2D is holding the reference of the Rigidbody2D component of

// attached game object.

_rigidbody2D.velocity = new Vector2(2.0f, _rigidbody2D.velocity.y);

}

Here, the we are constantly updating the velocity (2.0f) over the positive X-axis while keeping the velocity over Y-axis as it is.


# The reference of the documents are taken from the “Unity – Documentation”.

Muhammad Tashfiqul Bari

Mentor at Coursera