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

 

Understanding : Collider2D, Is-Trigger, PhysicsMaterial2D (Unity)

By | Unity3D | No Comments

Definition: By attaching the collider component, the game object can detect the collision with other game object in the game world. There are few types of collider such as BoxCollider2D, CircleCollider2D and etc. This collision detection mechanism can be implemented in 2 ways. This 2-ways of collision detection can be separated when “Is Trigger” is enable or disabled. We will go through with the details on our following discussion.

Collider

  • Material: “Physics Material 2D” are the materials where you can adjust the “friction” & “bounce” of your following game object. For example, let us consider the fact that we want our game object to be a little bouncy when it collides with another game object. So to do that, we first created a “Physics Material 2D” from our “Project” Tab,

Create Physics Material 2D

Now, to make it a little bouncy, let us change the value of “Bounciness” from “0” to “5”.

Physics Material

Finally, we will attach this “Physics Material 2D” to our “Material” section of our collider.

Collider With Material

So now, when we collide with any game object, it will bounce to a specific direction based on the angle, velocity and force.


  • Is Trigger: As we already said about the 2-ways of collision mechanism, here we are going to describe how these mechanism works.

-> Is Trigger (DISABLED): To understand the mechanism, let us see the following picture,

Collision - IsTrigger Disabled

-> Here, both of the game object has collider where “Is Trigger” is disabled. When the “GameObject – 2” collided with the “GameObject – 1”, It has been redirect to the opposite direction. Here the redirection depends on the velocity, force and angle of the incoming object (“GameObject  – 2”). But for the sake of the example, I just shown the opposite direction.

-> On the following example, we shown that the “GameObject – 1” didn’t moved from its place. It’s because either the game object doesn’t have the “Rigidbody2D” component (The Active Physics Component) or the mass of this game object is highly highly greater than the incoming game object.

-> To get the different state of collision such as, enter, exit & staying collided, please check on the following hyperlink. OnCollisionEnter2D, OnCollisionExit2D, OnCollisionStay2D.


-> Is Trigger (ENABLED):

Collider With Material(Is Trigger)

As we now understand the basic concept of the collision when “Is Trigger” is disabled, it will now be much easier for us to understand the concept when the “Is Trigger” is enabled. To explain this concept, we will use the following image,

Collision - IsTrigger Enabled

-> Here, the “GameObject – 2” is using the “CircleCollider2D” where “Is Trigger” is enabled. When the “GameObject – 2” has collided with the “GameObject – 1”, it didn’t redirect the incoming game object neither changed its position or rotation as the collider of the incoming game object has “Is Trigger” enabled. So now the question is, how this is going to help me on my development process?

MineField-> Let us consider that you have a mine field in your game. If the player comes near to the mine field, it will blow. So now if we use this collider to the mine field, and start detecting if the minefield has collider with the player by using “OnTriggerEnter2D” Method, then we can simply write down the code for player death animation and where the user interface should be redirect after the death of player.

-> To get the different state of collision with “Is Trigger” enabled such as, enter, exit & staying collided, please check on the following hyperlink. OnTriggerEnter2D, OnTriggerExit2D, OnTriggerStay2D.


  • Used By Effector: Right now, we will skip this section as we will describe with another post in more detail.

  • Offset: It is basically the displacement of the collider on the different axis (X, Y, Z). Here, on the following screenshot, we made positive “1” displacement of the collider, where the game object is staying where it was, but the collider is shifted 1 unit along the positive X-Axis.

Offset

  • Size: It denoted the size of the collider without changing the actual size of the game object itself. By default, the size of the collider is equal to the size of the game object (Here scale of the game object and size of the collider are not same. The same size mean where the size of the collider will be the size that required to give boundary of the following game object).

Size


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

Understanding : Transform, position, scale, rotate (Unity)

By | Unity3D | No Comments

Definition: Almost all the “GameObject” has a “Transform” component as its responsible to denote the position, rotation and scaling in the game world, where these values can be changed in 3 different axis (x, y, z).


Let’s break down each part for our own better understanding and see the usage of the “variables” & “function” that are mostly used from the “Transform” component.

  • transform: when we write “transform” in our script, it takes the reference of the “Transform” component that is attached with the “GameObject”. Let’s see the picture,

1

Here, the “Stick Man” game object has transform component which we can see in the “Inspector” view. When we write “transform” in our script, it asks the game object to pass him the reference of its own “Transform” component. So any change that you make with the “transform” in your script, it will make the change of “Transform” component of the “GameObject” (Stick Man) in the game world.


  • position: It is used to get/set the position of the “GameObject”. The “transform.position” takes “Vector3” as the argument. So now the question might be come, what is “Vector3”? Well, “Vector3” is the set of 3 variables, who represent the 3D vectors & points in the game world. Let’s see the picture below,

2

Here we can see the “Vector3” representation of the “Stick Man” “GameObject in the game world. So if we write “Debug.Log(transform.position);” in our script, we could see “(2,2,0)” as our output in the Unity Log.

 

But what if we want to change the position through the script, isn’t there anyway to do that? Yes, there are. If we would like to change the position through our script, we can use any of the following 2 ways to change the position.

position = new Vector3(5,4,3);

Vector3 ourNewPosition = new Vector3(5,4,3);

transform.position = ourNewPosition;


localPosition: It is used to get/set localPosition of the “GameObject” respect to its parent. Let’s see the following figure.

3

As we can see, the “transform.position” is showing the position of the “Hat” respect to the axis of the game world, where the “transform.localPosition” is showing the position of the “Hat” respect to “Stick Man” position as it’s the child of the “Stick Man” game object.


  • eulerAngles: It represent the rotation of the “GameObject” with respect to X/Y/Z axis in degrees. The “eulerAngles” take the argument as Vector3, where the X-represent the degrees around the X-Axis, Y-represent the degree around the Y-Axis and Z-represent the degree around the Z-Axis. I usually use “eulerAngle” when I want to read the rotation in degree around the Axis in world space. To simply read the rotation type,

 

Debug.Log(transform.eulerAngles);

 

Which will show rotation in degrees of the gameObject where the script has been attached.


  • Rotate: This function is responsible for rotating the gameObject over the x, y & z axis. “transform.Rotate” takes “Vector3” as the argument. So if someone write down “transform.Rotate(0,0,1)”, it means there is “1” degree of rotation over the Z-axis. One of the best practice I use to declare a “rotationSpeed” from the inspector, then by using
  • Vector2.left: (-1,0,0),
  • Vector2.right: (1,0,0),
  • Vector2.up: (0,1,0),
  • Vector2.down: (0,-1,0),
  • Vector2.forward: (0,0,1),
  • Vector2.back: (0,0,-1),

I decide which direction the gameObject will be rotate. So by simple typing down these to my script,

public float rotationSpeed;

                void Update(){ 

                transform.Rotate(Vector3.forward * rotationSpeed);

}

It will simply rotate the gameObject over the positive Z-axis with the declared rotation speed that has been assign in inspector.

Note: Like the “transform.localPosition” , we also have the “transform.localEulerAngle” for get/set the rotation respect to its parent. Let’s see some of the figure about the rotation in the given below.

Rotation X-AxisRotation Y-AxisRotation Z-Axis


  • transform.scale: It represent the scaling of the gameObject over the X,Y & Z axis. “transform.scale” also takes argument of “Vector3” where the “Vector3.x” represent scaling over the X-Axis, “Vector3.y” represent scaling over the Y-Axis & “Vector3.z” represent scaling over the Z-Axis.

So for example, if we want to scale a game object 50% over X-axis, then all we have to do is to write (we are considering the current scale as (1,1,1). )

transform.scale = new Vector(1.5,1,1);

  • localScale: It is used to get/set localScale of the “GameObject” respect to its parent. Let’s see the following figure.

Scaling X-AxisScaling Y-AxisScaling Z-Axis


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

Catch The Kitty – The Story of Bella

By | Blog | No Comments

Plot : The people around the world are getting so addictive to these touch screen, that these technologies are separating us from our emotions. Even if we are addicted to these touch screen, but the heart of our children still have the place for love and affection. Helping someone has become an obsolete term as we are so busy to focus on the touch screen rather than looking to our beautiful world that has been created by our beloved GOD. Humanity has been buried with these technologies, but the children of ours still born with these emotion as it is the high time we learn how to love again from our children ….

catch-the-kitty-the-story-of-bella


Stay tuned to know more about the game.

Thank you so much for all of your support.

 

Muhammad Tashfiqul Bari

Project Manager & Game Developer.

Workshop on “Introduction to Game Design and Game Development” by “FAITH Studio” & “UIUCCL”

By | Blog | 2 Comments

Introduction to Game Design and Game Development” workshop is organized by the “UIUCCL” (United International University Computer Club) and “FAITH Studio” in a vision to motivate the freshers of different university among the nation (DIU,BRAC,BUET,UIU). Here, in 2 days workshop, we tried to teach them how to

  • Creating/Managing Team.
  • Game Design.
  • How to track down team progress by using proper “Project Management Tool”.
  • How to develop the game by using proper game engine (Unity,Unreal).
  • How to test and evaluate the game.
  • How to market your game.
  • Write down the “High Concept Document”.
  • Presentation about their game idea based on the HCD.
  • Peer review from the other team and mentor.
  • Awarding the best game idea by showing the prototype of their game in #Unity.
  • Giving them an overview of “Unity” (Game Engine) interface and making their first project in game development.

To get the slide,please click on the given link.


High Concept Document: In this document, we can get a complete picture of the game by providing

  • Game name.
  • Game Type.
  • Platform.
  • Targeted Audience.
  • Game Story.
  • Game Objective.
  • Game Mechanics.
  • Game Level/Stages.
  • Character Prototype ( Digital/ Non-Digital).
  • How you want to market it.
  • How you are planning to generate revenue.

To get the template of HCD,please click on the given link.



Hands on Training over “Unity Engine”:

On the 2nd day,we tried to teach them

  • Installing Unity.
  • Overview over the interface.
  • Understanding the difference between 2D/3D game modes.
  • Understanding Transform,Rigidbody and Collider.
  • Introduction on C# and how it works for unity.
  • Writing down the “PlayerController” script for player movement.


I would also like to thanks team “Open Mind Studio” from “BRAC University” for their amazing idea they have given through the “High Concept Document”. The game project can be found out to the given link,which can be open bu the “Unity Editor”.

Here are some of the screenshot of the game:


Finally, I would like to thank to our beloved professor “Dr. Swakkher Shatabda” sir and brother “Mohammad Ali” for his excellent support to make the event successful. we really couldn’t have make the event succesfull  without their sincere,love and support.

 

Thank you once again for joining the event


Dr. Swakkher Shatabda .

Dr. Swakkher Shatabda .

Asst Professor at United International University

Dr. Shatabda is Assistant Professor and Undergraduate Program Co-ordinator of Computer Science and Engineering Department.

Mohammad Ali

Mohammad Ali

President of UIUCCL (United International University Computer Club)