pastemyst

player movement

(at edit #0)

present

(untitled)

C#copy raw

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerMovement : MonoBehaviour
{

public CharacterController2D controller;
    public Animator animator;

float horizontalMove;
    bool jump = false;
    bool crouch = false;
    public float runSpeed = 40f;
    public bool canDash = true;
    public bool isDashing;
    public float dashingPower = 24f;
    public float dashingTime = 0.2f;
    public float dashingCooldown = 1f;
    private bool isWallSliding;
    private float wallSlidingSpeed = 2f;
    private bool isFacingRight = true;
    private bool isWalljumping;
    private float wallJumpingDirection;
    private float wallJumpingTIme = 0.2f;
    private float wallJumpingCounter;
    private float wallJumpingDuration = 0.4f;
    private Vector2 wallJumpingPower = new Vector2(8f, 16f);

[SerializeField] private TrailRenderer tr;
    [SerializeField] Rigidbody2D rb;
    [SerializeField] private Transform wallcheck;
    [SerializeField] private LayerMask wallLayer;

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

// Update is called once per frame
   private void Update()
    {
        if (isDashing)
        {
            return;
        }

horizontalMove = Input.GetAxisRaw("Horizontal") * runSpeed;

animator.SetFloat("Speed", Mathf.Abs(horizontalMove));

if (Input.GetButtonDown("Jump"))
        {
            jump = true;
            animator.SetBool("isJumping", true);
        }

if (Input.GetButtonDown("Crouch"))
        {
            crouch = true;
        }
        else if (Input.GetButtonUp("Crouch"))
        {
            crouch = false;
        }

if (Input.GetKeyDown(KeyCode.LeftShift) && canDash)
        {
            StartCoroutine(Dash());
        }
        WallSlide();
        WallJump();

if (isWalljumping)
        {
          Flip();
        }
    }

public void OnLanding()
    {
        animator.SetBool("isJumping", false);
    }
    void FixedUpdate()
    {
        if (!isWalljumping)
        {
            controller.Move(horizontalMove * Time.fixedDeltaTime, crouch, jump);
        }     
        jump = false;
        if (isDashing)
        {
            return;
        }
    }

private bool IsWalled()
    {
        return Physics2D.OverlapCircle(wallcheck.position, 0.2f, wallLayer);
    }
    
    private void WallSlide()
    {
        if (IsWalled() && !controller.m_Grounded && horizontalMove !=0f) 
        {
           isWallSliding = true;
           rb.velocity = new Vector2(rb.velocity.x, Mathf.Clamp(rb.velocity.y, -wallSlidingSpeed, float.MaxValue ));
        }
        else
        {
            isWallSliding = false;
        }
    }

private void WallJump()
    {
        if (isWallSliding)
        {
            isWallSliding = false;
            wallJumpingDirection = -transform.localScale.x;
            wallJumpingCounter = wallJumpingTIme;

CancelInvoke(nameof(StopWallJumping));
        }
        else
        {
            wallJumpingCounter -= Time.deltaTime;
        }

if(Input.GetButtonDown("Jump") && wallJumpingCounter > 0f)
        {
            isWalljumping = true;
            rb.velocity = new Vector2(wallJumpingDirection * wallJumpingPower.x, wallJumpingPower.y);
            wallJumpingCounter = 0f;

if (transform.localScale.x != wallJumpingDirection)
            {
                isFacingRight = !isFacingRight;
                Vector3 localScale = transform.localScale;
                localScale.x *= -1f;
                transform.localScale = localScale;
            }

Invoke(nameof(StopWallJumping), wallJumpingDuration);
        }
    }

private void StopWallJumping()
    {
        isWalljumping = false;
    }

private IEnumerator Dash()
    {
        canDash = false;
        isDashing = true;
        float originalGravity = rb.gravityScale;
        rb.gravityScale = 0f;
        rb.velocity = new Vector2 (transform.localScale.x * dashingPower ,0f);
        tr.emitting = true;
        yield return new WaitForSeconds(dashingTime);
        tr.emitting = false;
        rb.gravityScale = originalGravity;
        isDashing = false;
        yield return new WaitForSeconds(dashingCooldown);
        canDash = true;
    }
    private void Flip()
    {
        if (isFacingRight && horizontalMove < 0f || !isFacingRight && horizontalMove > 0f)
        {
            isFacingRight = !isFacingRight;
            Vector3 localScale = transform.localScale;
            localScale.x *= -1f;
            transform.localScale = localScale;
        }
    }
}

created at:

stats: 180 lines, 404 words, 4.66kb