How do i add Vertical movement

How would i add vertical movement to this script.
its unityStandard assets, i don`t use crouch or jump.

using System;
using UnityEngine;

namespace UnityStandardAssets._2D
{
    public class PlatformerCharacter2D : MonoBehaviour
    {
        [SerializeField] private float m_MaxSpeed = 10f;                    // The fastest the player can travel in the x axis.
        [SerializeField] private float m_JumpForce = 400f;                  // Amount of force added when the player jumps.
        [Range(0, 1)] [SerializeField] private float m_CrouchSpeed = .36f;  // Amount of maxSpeed applied to crouching movement. 1 = 100%
        [SerializeField] private bool m_AirControl = false;                 // Whether or not a player can steer while jumping;
        [SerializeField] private LayerMask m_WhatIsGround;                  // A mask determining what is ground to the character

        private Transform m_GroundCheck;    // A position marking where to check if the player is grounded.
        const float k_GroundedRadius = .2f; // Radius of the overlap circle to determine if grounded
        public bool m_Grounded;            // Whether or not the player is grounded.
        private Transform m_CeilingCheck;   // A position marking where to check for ceilings
        const float k_CeilingRadius = .01f; // Radius of the overlap circle to determine if the player can stand up
        private Animator m_Anim;            // Reference to the player's animator component.

        Transform playerGraphics;



        private Rigidbody2D m_Rigidbody2D;
        private bool m_FacingRight = true;  // For determining which way the player is currently facing.

        private void Awake()
        {
            // Setting up references.
            m_GroundCheck = transform.Find("GroundCheck");
            m_CeilingCheck = transform.Find("CeilingCheck");
            m_Anim = GetComponent<Animator>();
            m_Rigidbody2D = GetComponent<Rigidbody2D>();
            playerGraphics = transform.Find ("Graphics");
            if (playerGraphics == null)
            {
                Debug.LogError ("Lets freak out! there is no");
            }
        }


        private void FixedUpdate()
        {
            m_Grounded = false;

            // The player is grounded if a circlecast to the groundcheck position hits anything designated as ground
            // This can be done using layers instead but Sample Assets will not overwrite your project settings.
            Collider2D[] colliders = Physics2D.OverlapCircleAll(m_GroundCheck.position, k_GroundedRadius, m_WhatIsGround);
            for (int i = 0; i < colliders.Length; i++)
            {
                if (colliders[i].gameObject != gameObject)
                    m_Grounded = true;
            }
            m_Anim.SetBool("Ground", m_Grounded);

            // Set the vertical animation
            m_Anim.SetFloat("vSpeed", m_Rigidbody2D.velocity.y);
        }


        public void Move(float move, bool crouch, bool jump)
        {
            // If crouching, check to see if the character can stand up
            if (!crouch && m_Anim.GetBool("Crouch"))
            {
                // If the character has a ceiling preventing them from standing up, keep them crouching
                if (Physics2D.OverlapCircle(m_CeilingCheck.position, k_CeilingRadius, m_WhatIsGround))
                {
                    crouch = true;
                }
            }

            // Set whether or not the character is crouching in the animator
            m_Anim.SetBool("Crouch", crouch);

            //only control the player if grounded or airControl is turned on
            if (m_Grounded || m_AirControl)
            {
                // Reduce the speed if crouching by the crouchSpeed multiplier
                move = (crouch ? move*m_CrouchSpeed : move);

                // The Speed animator parameter is set to the absolute value of the horizontal input.
                m_Anim.SetFloat("Speed", Mathf.Abs(move));

                // Move the character
                m_Rigidbody2D.velocity = new Vector2(move*m_MaxSpeed, m_Rigidbody2D.velocity.y);

                // If the input is moving the player right and the player is facing left...
                if (move > 0 && !m_FacingRight)
                {
                    // ... flip the player.
                    Flip();
                }
                    // Otherwise if the input is moving the player left and the player is facing right...
                else if (move < 0 && m_FacingRight)
                {
                    // ... flip the player.
                    Flip();
                }
            }
            // If the player should jump...
            if (m_Grounded && jump && m_Anim.GetBool("Ground"))
            {
                // Add a vertical force to the player.
                m_Grounded = false;
                m_Anim.SetBool("Ground", false);
                m_Rigidbody2D.AddForce(new Vector2(0f, m_JumpForce));
            }
        }


        private void Flip()
        {
            // Switch the way the player is labelled as facing.
            m_FacingRight = !m_FacingRight;

            transform.Rotate (0f, 180f, 0);
        }
    }
}

That uses physics which might be a problem. There’s an answer here for simple movement:

That might have some problems though because you will need collisions and translate doesn’t perform collisions well. The idea works, though. instead of going horizontal, you are getting the vertical movement and moving vertical. I’m guessing. Anyway, rewriting that script might be more trouble than it’s worth. Maybe start out with that answer and build on it, adding collisions or whatever you need.

Try to find some simpler controller scripts for examples. Just do a search for unity simple 2d controller.

That’s how I done a 2D movement script (Top-Down). However, I’m not that happy with it because currently, If I attach an image/text on the player controller, it causes the UI to behave in a VERY unpleasant fashion. Something I’m currently trying to work out. Anyway, hope this gives you some insight for what you’re trying to achieve. :slight_smile:

 if (Input.GetKey(KeyCode.W)|| Input.GetKey(KeyCode.UpArrow)) // Move Forward
        {
            player.transform.Translate(Vector2.up * speed * Time.deltaTime, Space.World);
            transform.eulerAngles = new Vector2(0, 180);
        }

        if (Input.GetKey(KeyCode.S) || Input.GetKey(KeyCode.DownArrow)) // Move Bacward
        {
            player.transform.Translate(Vector2.down * speed * Time.deltaTime, Space.World);
            transform.eulerAngles = new Vector2(0, 0);
        }

        if (Input.GetKey(KeyCode.A) || Input.GetKey(KeyCode.LeftArrow)) // Move Left
        {
            player.transform.Translate(Vector2.left * speed * Time.deltaTime, Space.World);
            transform.localEulerAngles = new Vector3(0,0,-90);
        }

        if (Input.GetKey(KeyCode.D) || Input.GetKey(KeyCode.RightArrow)) // Move Right
        {
            player.transform.Translate(Vector2.right * speed * Time.deltaTime, Space.World);
           transform.localEulerAngles = new Vector3(0,0,90);
        }

How can i flip the horizontal axis, so my image flips.

the transform.eulerAngles don’t work?

            faceRight = !faceRight;
            Vector3 Pscale = transform.localScale;
            Pscale.x *= -1;
            transform.localScale = Pscale;

This is another way that I flip the player. faceRight is a bool set to true from start since in my game it is true. Your game may be different, however.

Then I designed a vector 3 for the Player’s scale. Your Transform consist of transform.position, transform.rotate, and transform.localScale. The local scale, if you notice, will make your player grow if added positive; however, -1 will flip the player and make it grow in the opposite direction. So is what I done is multiplied the Player’s local scale by -1. A negative multiplied by a negative becomes a positive. So I’m directly accessing the X-axis and multiplying it by -1. The result will either be -1 or 1.

Then I tell my program to take that information and make it my player’s local scale.

I used a function called Pflip(){} and call it in a FixedUpdate(). This works best for what I’m doing. Also, I heard that FixedUpdate is a superior function for movement.

It took me a really long time to get this code put together so I hope that it helps you! Do lots of research and try to understand everything that I’ve mentioned.Perhaps you find a more optimal way? Do share!