Answers for "unity movement script 2d"

how to make 2d movement in unity

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class movement2D : MonoBehaviour
{
    Rigidbody2D body;

    float horizontal;
    float vertical;

    public float runSpeed = 10.0f;
    
    
    // Start is called before the first frame update
    void Start()
    {
        body = GetComponent<Rigidbody2D>();        
    }

    // Update is called once per frame
    void Update()
    {
        horizontal = Input.GetAxisRaw("Horizontal");
        vertical = Input.GetAxisRaw("Vertical");
    }

    private void FixedUpdate()
    {
        body.velocity = new Vector2(horizontal * runSpeed, vertical * runSpeed);   
    }
}

2d movement unity

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Movement : MonoBehaviour
{
	//for A&D  /  Right&Left Arrow And Jump Movement
    //for Adding W&S Movement, Remove The Slashes Below And Add Slashes 
    //To Jump Movement Only Also In RigidBody2D Remove Gravity For It
    
    public Rigidbody2D rb;
    private bool IsGrounded = true;
    private float MoveX;
    //private float MoveY;
    private bool DoDeath = true;
    public GameObject DeathScreen;
    public GameObject LevelCompleteScreen;
    void Start()
    {
        DeathScreen.gameObject.SetActive(false);
        LevelCompleteScreen.gameObject.SetActive(false);
        rb = GetComponent<Rigidbody2D>();
    }

    // Update is called once per frame
    void FixedUpdate()
    {
        Debug.Log(IsGrounded);
        if(Input.GetButtonDown("Jump") && IsGrounded)
        {
        	//Remove These 2 Lines Below For W&s Movement Only
            
            rb.AddForce(new Vector2(0,500));
            IsGrounded = false;
        }

        MoveX = Input.GetAxisRaw("Horizontal");
        Remove The Slashes For W&S Movement Only
        //MoveY = Input.GetAxisRaw("Vertical");
        //Slash The Below Line Out For W&S Movement Only
        
        rb.AddForce(new Vector2(MoveX * 20, 0));
        //Remove The Slashes For W&S Movement Only
        
        //rb.velocity = (new Vector2(MoveX * 20, MoveY * 20));
        
        
    }
    public void OnTriggerEnter2D(Collider2D ob)
    {
        if(DoDeath)
        {
            if(ob.name == "DeathTrigger")
            {
                DeathScreen.gameObject.SetActive(true);
            }
            if(ob.name == "Finish")
            {
                LevelCompleteScreen.gameObject.SetActive(true);
                DoDeath = false;
            }
        }
    }
    public void OnCollisionEnter2D()
    {
        IsGrounded = true;
    }
}

2d movement script unity

using UnityEngine;
using UnityEngine.Events;

public class CharacterController2D : MonoBehaviour
{
	[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%
	[Range(0, .3f)] [SerializeField] private float m_MovementSmoothing = .05f;	// How much to smooth out the movement
	[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
	[SerializeField] private Transform m_GroundCheck;							// A position marking where to check if the player is grounded.
	[SerializeField] private Transform m_CeilingCheck;							// A position marking where to check for ceilings
	[SerializeField] private Collider2D m_CrouchDisableCollider;				// A collider that will be disabled when crouching

	const float k_GroundedRadius = .2f; // Radius of the overlap circle to determine if grounded
	private bool m_Grounded;            // Whether or not the player is grounded.
	const float k_CeilingRadius = .2f; // Radius of the overlap circle to determine if the player can stand up
	private Rigidbody2D m_Rigidbody2D;
	private bool m_FacingRight = true;  // For determining which way the player is currently facing.
	private Vector3 m_Velocity = Vector3.zero;

	[Header("Events")]
	[Space]

	public UnityEvent OnLandEvent;

	[System.Serializable]
	public class BoolEvent : UnityEvent<bool> { }

	public BoolEvent OnCrouchEvent;
	private bool m_wasCrouching = false;

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

		if (OnLandEvent == null)
			OnLandEvent = new UnityEvent();

		if (OnCrouchEvent == null)
			OnCrouchEvent = new BoolEvent();
	}

	private void FixedUpdate()
	{
		bool wasGrounded = m_Grounded;
		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;
				if (!wasGrounded)
					OnLandEvent.Invoke();
			}
		}
	}


	public void Move(float move, bool crouch, bool jump)
	{
		// If crouching, check to see if the character can stand up
		if (!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;
			}
		}

		//only control the player if grounded or airControl is turned on
		if (m_Grounded || m_AirControl)
		{

			// If crouching
			if (crouch)
			{
				if (!m_wasCrouching)
				{
					m_wasCrouching = true;
					OnCrouchEvent.Invoke(true);
				}

				// Reduce the speed by the crouchSpeed multiplier
				move *= m_CrouchSpeed;

				// Disable one of the colliders when crouching
				if (m_CrouchDisableCollider != null)
					m_CrouchDisableCollider.enabled = false;
			} else
			{
				// Enable the collider when not crouching
				if (m_CrouchDisableCollider != null)
					m_CrouchDisableCollider.enabled = true;

				if (m_wasCrouching)
				{
					m_wasCrouching = false;
					OnCrouchEvent.Invoke(false);
				}
			}

			// Move the character by finding the target velocity
			Vector3 targetVelocity = new Vector2(move * 10f, m_Rigidbody2D.velocity.y);
			// And then smoothing it out and applying it to the character
			m_Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref m_Velocity, m_MovementSmoothing);

			// 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)
		{
			// Add a vertical force to the player.
			m_Grounded = 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;

		// Multiply the player's x local scale by -1.
		Vector3 theScale = transform.localScale;
		theScale.x *= -1;
		transform.localScale = theScale;
	}
}

2d player movement unity

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    [Header("Player Movement")]
    private Rigidbody2D rb;
    [SerializeField] private float speed, jumpForce, checkRadius;
    private float input;
    [SerializeField] private Transform groundCheck;
    private bool isGround;
    [SerializeField] private LayerMask groundLayerMask;
    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    // Update is called once per frame
    void Update()
    {
        isGround = Physics2D.OverlapCircle(groundCheck.position, checkRadius, groundLayerMask);
        input = Input.GetAxisRaw("Horizontal");
    }
    void FixedUpdate(){
        rb.velocity = new Vector2(input * speed * Time.deltaTime, rb.velocity.y);
        if (isGround && Input.GetKey(KeyCode.Space))
        {
            rb.velocity = Vector2.up * jumpForce * Time.deltaTime;
        }
    }
}

unity movement script 2d

//This is a script for a 2D plataformer type of movement.
//This script includes the movement, flipping the player and a ground check if you need one.
/*
  This is a two in one grepper answer, 
  the script flips the player by rotating it,
  and when it rotates, if the camera 
  is attached to the player the normal way, 
  its going to rotate the hole camera.
  and the only way to fix that bug is by making it so 
  the camera follows you with code, 
  if you scroll all the way down you can find the code that makes 
  the camera follow the player.
*/

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float movementSpeed = 1;
    private Rigidbody2D rb;
    public float JumpForce = 1;
    //If the character flipps the wrong way change this variable to false.
    public bool facingRight = true;
    public Camera cam;
    public bool isGrounded = false;
    public Transform GroundCheck;
    public LayerMask Ground;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
    }

    void Update()
    {
        Xmovement();
        GroundCheck();
        Jump();
        
        void Xmovement()
        {

         var movement = Input.GetAxis("Horizontal");
         transform.position += new Vector3(movement, 0, 0) * Time.deltaTime * movementSpeed;
                
            if (Input.GetAxis("Horizontal") > 0)
            {
                facingRight = false;
            }
            if (Input.GetAxis("Horizontal") < 0)
            {
                facingRight = true;
            }
            //Flipping the player
            if (facingRight) {
            transform.eulerAngles = new Vector3(0, 180, 0);
            }

        }

        void Jump()
        {
            if (Input.GetButtonDown("Jump") && Mathf.Abs(rb.velocity.y) < 0.001f)
            {
                rb.AddForce(new Vector2(0, JumpForce), ForceMode2D.Impulse);
            }
        }

        void GroundCheck()
        {
            if (Mathf.Abs(rb.velocity.y) < 0.001f)
            {
                isGrounded = true;
            }

            else
            {
                isGrounded = false;
            }
        }
    }
}  





/*
	Read the commented lines on the top of the answer for context.
*/
using UnityEngine;

public class CameraFollow : MonoBehaviour
{
    public Camera cam;

    public Transform subject;

    // Update is called once per frame
    void LateUpdate()
    {
        cam.transform.position = subject.transform.position ;
    }
}

unity 2d movement

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
	bool isGrounded = true;
    RigidBody2D rb;
    
    
    private void Start() 
    {
    	rb = GetComponent<RigidBody2D>();
    }
    
    private void FixedUpdate()
    {
    	if(isGrounded && Input.GetButtonDown("Jump")) 
        {
        	rb.AddForce(new Vector2(0, 200));
			IsGrounded = false;
        }
        
        isGrounded = true;
    }	
}