• Every code must be written in main() function.
  • main() function is the entry point of the C++
  • Code in main() is the first to be executed

    #include

• Directive
• Used to include head files.
  • Head files contains declarations of functions and objects that program can use.
• #include <iostream> includes the iostream header, which provides objects like std::cout for outputting text to the console.

Variables

• Hold data values.
• Store, manipulate, display informations.
• Initialize variable.

  Vaiable_type Variable_name = value;

• int --> represents whole numbers.
• float || double --> represents real numbers.
  • float --> decimal numbers // up to 7 decimal digits.
  • double --> with more precisions // up to 15 - 17 decimal digits.

    float variable_name = 99.99f;

String

• To use string in C++, include <string> should be added on top of the code.
• 2 ways to implement*
  1. Adding using namespace std; after the #include <string>
  2. std::string cariable_name = "This is a string."

     #include <string>
     using namespace std; // method 1
     int main() {
     string s1 = "Hello."; // method 1
     std::string s2 = "Hello."; // method 2
     return 0;
      }

Boolean

• Only 2 possible values, true || false

  bool variable_true = true;
  bool variable_false = false;

• When printing boolean values using cout, true --> 1 false --> 0

Char

• Represents single character
• keyword = char

  char variable_name = 'h';

Constants // Keyword const

• Variables that can't be changed once it's intialized. const int max_value = 100;
  • max_value can't be changed.

• I have simple movements for now, which is just moving, jumping.

  Goal is to implement wall jumping mechanic.

• I think it might take a while to achieve wall jumps because it's quite complicated.
• This post is about me going through trials & errors and record what I did.

How to Wall Jump

Steps

1. Detect walls if the player is walking into the wall.
2. If the player is not on the ground and pressing towards the wall, the player starts sliding down the wall.
3. If the player is sliding down the wall, and the player is pressing jump button, force is applied on the opposite side of x value where the player is facing.

Write the code

• I have to detect the wall first

  public Transform wallCheck;
  public LayerMask wallLayer;
    void Update()
    {
        if(WallCheck())
        {
            Debug.Log("Is wall");
        }
    }
    bool WallCheck()
    {
        return Physics2D.OverlapCircle(wallCheck.position, 0.2f, wallLayer);
    }
  
    private void OnDrawGizmos()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(wallCheck.position, .2f);
    }

  

• I did OnDrawGizmos() to visualize the Physics2D.OverlapCircle()

• If the OverlapCircle() hits the wall layer, on the console it should say "Is wall".

  Wall Slide

• If the player is not on the ground, and pressing against the wall, it should slide down the wall.

  void WallSlide()
    {
        if (!isGround && WallCheck() && h != 0f)
        {
            isWallSliding = true;
            rigid.velocity = new Vector2(rigid.velocity.x, Mathf.Clamp(rigid.velocity.y, -wallSlidingSpeed, float.MaxValue));
        }
    }

  Mathf.Clamp() : Constrains a value within a specified range.

  Mathf.Clamp(float value to be clamped, float min, float max)

  The function returns

• The original value if it's within the specified range.

• The minimum value if the original value is less than the minimum.

• The maximum value if the original value is greater than the maximum.

• Mathf.Clamp() is used to prevent accelerating while sliding down the wall.

void WallSlide()
    {
        if (!isGround && WallCheck() && h != 0f)
        {
            isWallSliding = true;
            rigid.velocity = new Vector2(rigid.velocity.x, Mathf.Clamp(rigid.velocity.y, -wallSlidingSpeed, float.MaxValue));
        }
        else
        {
            isWallSliding = false;
        }
    }

• Lastly, else is isWallSliding = false;

Just "jumping" is easier than I thought.

• Make a variable for our jumpingPower, and use it to control our jump heights.

if (Input.GetButtonDown("Jump"))
        {
            rigid.AddForce(Vector2.up * jumpPower, ForceMode2D.Impulse);
        }

• We're adding force to our rigidbody 2D, so wirte rigid.Addforce.
• We're jumping, which means up. Therefore, do Vector2.up and multiply by the number of jumpPower.

• Now we are able to make our gameObject jump. However, you can jump infinitely.
• This can be solved by checking if the player is touching the ground or not.

How to Check Ground with Boxcast

Pseudo Code: If the player is touching the ground and pressing jump button, the player can jump. If the player is not touching the ground, the player can't jump.

• Based on the pseudo code, we first need to know if our player is on the ground or not.
• We will use Physics2D.Boxcast() to check if the player is on the ground or not.

Physics.Boxcast() creates a box-shaped volume and detects collision, which returns a boolean value.

Boxcast Parameters:

Physics2D.Boxcast(Vector2 origin, Vector2 size, float angle, Vector2 direction, float distance, int layerMask)

Make Variables for the Ground Check

We need to make variables that will go into the Boxcast parameters.

• Vector2 to size our cast box.
• float value to control the distance between the player's position and box cast.
• Layermask to check which layer we are detecting for.

public bool IsGround()
    {
        if (Physics2D.BoxCast(transform.position, boxSize, 0, -transform.up, distance, groundLayer))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

• We will make a new bool called IsGround() so we can use it to check if the player is on the ground.

• We can plug our variables into the Boxcast parameters. I don't want any angles so I put 0 as a angle value. I want to check what's under our player, so I did -transform.up.

  There's no transform.left or transform.down in transform components.

• Since it's a boolean, we'll return true if our Boxcast is detecting the ground, and return false if it's not detecting any ground.

Visualize the Boxcast

Boxcast is not visible by default, so it's difficult to control it.

private void OnDrawGizmos()
    {
        Gizmos.DrawWireCube(transform.position - transform.up * distance, boxsize);
    }

• We'll use void OnDrawGizmos().

  void OnDrawGizmos() is a tool that draws the visual represent for the gizmos. It's primarily used to debug or visual purposes.

• We can use Gizmos.DrawWireCube to visualize our Boxcast.

  Gizmos.DrawWireCube draws wired cube to visualize the box.

• Use (transform.position - transform.up * distance, boxsize);

  We want our center for the box to be same as Boxcast, which is why we did transform.position - transform.up. Then, we multiply it by the distance value to control the boxcast's y-axis location.

• Now we can visualize Boxcast and control it.

Make Ground Layer in the Layer component

Now we can make a Layer called "Ground" to detect the ground.

• Click Layer that's on the inspector window, and click Add Layer.

• Add the layer and name it "Ground".
• Make sure you select the layer after saving it.

• Then, go to the player's script and select Ground layer.

Jump only Once using Ground Check

• Now, we'll make a void Jump() and call it in Update() to jump.

 void Jump()
    {
        if (Input.GetButtonDown("Jump") && IsGround())
        {
            rigid.AddForce(Vector2.up * jumpPower, ForceMode2D.Impulse);
        }

    }

• If the player is pressing jump button and the player is on the ground, we'll add force to the player to go up.

• Now we can only jump when we are on the ground.
• Make sure you called the void Jump() in the Update() and selected the groundLayer in the player's script.

• If you follwed the last tile map tutorial, our tilemap already should have tilemap collider 2D.

• If you start moving, you'll see our player gameObject moving up and down randomly.

  • This is because our tilemap collider is applied to each individual tiles.

Solution

• To fix this, add Composite Collider 2D.

  Composite collider 2D merges all of the collider 2D, and in this case it will help merge all of the tiles into one big collider.

• Make sure you check the Used By Composite in Tilemap Collider 2D, and change body type to Static in RigidBody 2D component.

Static body type do not move under physics simulation. It is an immovable object with infinite mass.

• Now it should be moving fine!

Rigidbody2D rigid;

    float h;


      private void Awake()
    {
        rigid = GetComponent<Rigidbody2D>();
    }

    private void FixedUpdate()
    {
        h = Input.GetAxisRaw("Horizontal");

        rigid.AddForce(Vector2.right * h, ForceMode2D.Impulse);
    }

• Moving the gameObject by adding force is little bit different from changing the velocity of the gameObject.

rigid.AddForce(Vector2.right * h, ForceMode2D.Impulse);

• AddForce is a method that can apply force to rigidbody 2D.

• We are not using any specified Vector2 value, so we'll use Vector2.right Reason why we're using Vector2.right is because .right is a positive number. If we did .left the gameObject will move opposite as to where we want it to move since it's negative number.

• To make it move, we will multiply h value to Vector2.right

• We will use ForceMode2D.Impulse to move our player gameObject.

• When using AddForce method, there's ForceMode2D.Impulse and ForceMode2D.Force.

• ForceMode2D.Force applies continuous force to the gameObject.

• ForceMode2D.Impulse applies instant force to the gameObject.

• Now we are able to make out gameObject move, but it's moving inconsistently and really fast.

• This is because we wrote the code in FixedUpdate()

• We are applying instant force to the rigidbody 2D for every 50 frames, which is why it's accelerating.

Setting the Max Speed Limit

To stop this from happening, we can set MaxSpeed value.

• It's helpful to pseudo code before writing the actual code.

        //if rigid's positive x velocity is bigger than the maxSpeed
        //then rigid's positive x velocity is maxSpeed
        //if rigid's negative x velocity is bigger than the maxSpeed * -1
        //then rigid's negative x velocity is maxSpeed * -1

• After doing so, write it in code terms. In this case,

if(rigid.velocity.x > maxSpeed)
{
    rigid.velocity = new Vector2(maxSpeed, rigid.velocity.y);
}
else if(rigid.velocity.x < maxSpeed * (-1))
{
    rigid.velocity = new Vector2(maxSpeed * (-1), rigid.velocity.y);
}

Now we should be able to move our player gameObject.

Control GameObject from sliding

• One Problem is our charcter starts sliding after the player stoped moving. This can be solved by assigning a new Vector2 value when the player stops pressing onto the keyboard.

  Pseudo Code:

  //if the player stops pressing the keyboard, //then rigid will assign new x velocity value to decrease speed.

Apply to the code:

    private void Update()
    {
        if (Input.GetButtonUp("Horizontal"))
        {
            rigid.velocity = new Vector2(rigid.velocity.normalized.x, rigid.velocity.y);
        }
    }

• We will use Update() since we want to consistently decrease the gameObject's velocity.

• normalized converts the Vector to a unit vector, meaning it will have magnitude to 1 while maintaining the original direction.

• It should look like this.

Next:

Setting the tilesmap(platform) so the gameObject doens't collide with individual tilemap.

Get the gameObject's axis value

To move the character, you have to apply force to them by either changing the gameobject's velocity or by applying force to them.

• After getting the component from Awake(), you can manipulate it in the FixedUpdate() to move it.

      Rigidbody2D rigid;
  
      float h;
      public float walkSpeed;
  
        private void Awake()
      {
          rigid = GetComponent<Rigidbody2D>();
      }
  
      private void FixedUpdate()
      {
          h = Input.GetAxisRaw("Horizontal");
  
          rigid.velocity = new Vector2(h * walkSpeed, rigid.velocity.y);
      }

• In the FixedUpdate, we need a variable to store our Input.GetAxisRaw code.

Input.GetAxisRaw gets the value of virtue axis. For this case, -1 or 1 for x-axis.

• To store our Input.GetAxisRaw, we declare h as our float value before Awake() and set h = Input.GetAxisRaw("Horizontal")

• "Horizontal" is unity's built in system which captures the gameObjects horizontal movements. By default it is set to left arrow & right arrow and a & d keys on the keyboard.
• This can be found on Edit -> Project Settings -> Input Management.

• As you can see there's a lot of other inputs that we can use.
• If you want to change the number of inputs, you can change the size number.

Apply the velocity to the Rigidbody 2D

  Rigidbody2D rigid;

      float h;
      public float walkSpeed;

        private void Awake()
      {
          rigid = GetComponent<Rigidbody2D>();
      }

      private void FixedUpdate()
      {
          h = Input.GetAxisRaw("Horizontal");

          rigid.velocity = new Vector2(h * walkSpeed, rigid.velocity.y);
      }
  }

• Now we need to write a code to change the velocity of the gameObject.

  rigid.velocity = new Vector2(h * walkSpeed, rigid.velocity.y);

• We are going to tap in to our rigidbody 2D's velocity so write rigid.velocity

• Since we want to specify our Vector2, we will use new Vector2

new Vector2 is used when we need to create a new Vector2 with specific x and y components.

• For our x-axis value, we will use h value which is -1 or 1, since we want to move from left to right.

• For our y-axis value, we don't want to move vertically when we move horizontally. Therefore, we will leave it as it is. This can be done by rigid.velocity.y.

rigid.velocity = new Vector2(h, rigid.velocity.y);

• Our gameObject can move with this code, but it will only move at -1 or 1 speed becuase of our h value which is our Input.GetAxisRaw("Horizontal") value.

• We can solve this problem by making another variable called public float walkSpeed; before Awake().

• By making public float walkSpeed; public, we can access it from the gameObject's script section from the inspector window.

• Now, we can multiply the walkSpeed to our h value to make it go faster.

rigid.velocity = new Vector2(h * walkSpeed, rigid.velocity.y);

Make sure to save the script before playing the scene!

Constraints

• When you start moving, the gameObject might rotate.

• This can be fixed by freezing the gameObject's z-axis in constraints for Rigidbody 2D component.

Next

Apply force to the gameObject to move.

Awake()

public class PlayerMove : MonoBehaviour
{
    Rigidbody2D rigid;

      private void Awake()
    {
        rigid = GetComponent<Rigidbody2D>();
    }


}

• Get the gameObject's Rigidbody2D componenet and set name for it. For this case it's rigid, but you can call it however you want like rb or body2D.

• In the Awake(), use GetComponent<> to access and manipulate the component. We're going to manipulate Rigidbody2D here so I did

  rigid = GetComponenet<Rigidbody2D>();

  Make sure to put () after the <> to complete the code.

Now we can move on to actually writing the code so our player gameobject can move.

RigidBody 2D adds 2D physics(falling for example) to the gameObject.

• Select AddComponent and type RigidBody 2D
• Adding RigidBody 2D will enable the gameObject to interact with eachother.

Adding Collider 2D

Collider 2D defines the physical shape of a 2D GameObject for the purposes of physics interactions.

• Allows the gameObject to collide with other gameObjects and trigger events.

Adding Scripts 1

By adding a script to the game object, you can define how the gameObject behaves.

• Click on Add Component and type script. Then, name the script and save it.

• Once you save the script, wait for few seconds and the script should be in your Assets folder.

Adding Scripts 2

I prefer to make a script folder first, and then make a script.

• Create a new folder under Assests folder.

• Name the folder and create C# script in it.

• Make sure to drag and drop the script onto the add component section of the gameObject to apply the script after.

Tilemap is a tool used for storing tile assets and build level designs.

• To make a tilemap, right click on the hierarchy, go to 2D object -> Tilemap -> Rectangular
• Try to play around with Tilemap section and see what each one of them does. But in this case, I'll use rectangular.

• After creating a tilemap heirarchy, go to tile pallet window and create new pallet.

• Once you create a new pallet, save it.

• I create new folder "Tiles" and save the pallet in there to manage it easily.

• After saving the tile pallet in the Tiles file, create a new 2D sprite by following the steps above picture.
• Then, drag the 2D sprite into the tile pallet.

• Lastly, add Tilemap Collider 2D componenet in the inspector window like above. This will add collider to the tilemap so the player can stay above it.
• Make sure the player has collider and rigidBody 2D applied!

Before starting, I customized my unity starting screen, so I can see the game view and scene window at the same time. For the Bottom half I put my hierarchy, project, and tile pallet window for easy access. I found out this layout works the best for me, so try moving around the windows and see what layout works the best for you.

How to create 2D gameObjects

• To create 2D sprites, right-click on the heirarchy window.

• Go to 2D Object -> Sprites. I generally use Triangle or squre sprites before applying the actual animated sprites.

  How to Control GameObjects

  

  Move around the scene

• Short cut for this action is "q" on the keyboard.

• It's pretty straight forward. You can move around the scene.

  Move the 2D GameObject

  

• Short cut for this action is "w" on the keyboard.

• Pressing on the blue rectangle in the middle, you can move around the 2D gameObject freely.

• Pressing on the green arrow, which is y-axis, you can only move the 2D gameObject in the y-axis.

• Pressing on the red arrow, which is x-axis, you can only move the 2D gameObject in the x-axis.

  Rotate the 2D GameObject

  

• Short cut for this action is "e" on the keyboard.

• You can rotate the sprite by pressing on the blue line.

• I suggest to play around with it and see how it works.

  Stretch the 2D GameObject

  

• Short cut for this action is "r" on the keyboard.
• You can stretch the sprite along the y-axis or x-axis.

1. void Awake()

• Initializes variables and set up game states before starting the game.

void OnEnable()

• Executes when the gameObject is enabled.

void start()

• Happens right before the Update() part of the code

void FixedUpdate()

• Operates in consistent "fixed" time interval
• Uses about 50fps
• Suitable for physics calculations, ex) applying forces to rigid body.

void Update()

• Called "once per frame"
• implement game logic || behaviors that needs to be updated frequently. Ex) Jump
• Main game logic is coded in Update() such as checking for users input, updating non-obj position
• interval b/w Update() might vary due to the environment setting. Ex) pc specs
• deals with user input, moving obj, or update animations etc.
• important to account for time-based operations b/w frames. Generally sovled but using Time.deltaTime method.

void LateUpdate()

• works silmilar with Update(), but executed after Update() is finished.
• Ex) adjusting the camer position || animations after some objects have been "updated"

void OnDisable()

• executes when the gameObject is disabled.

void OnDestroy()

• executes when the gameObject gets destroyed