Сенсорный контроллер Unity2D и обнаружение смахивания

Question

Я пытаюсь написать сценарий контроллера персонажа для моего главного героя 2D-платформы. Я хочу использовать левую сторону экрана телефона для перемещения игрока влево / вправо и правую сторону экрана для прыжков и рывков. Как в Android версии игр Limbo или oddmar . Я не хочу использовать кнопки, вместо этого я хочу использовать смахивание, например смахивание вправо для перемещения вправо, влево для перемещения влево и т. Д. c. До сих пор я написал этот сценарий:

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

public class TouchController : MonoBehaviour
{
    private Rigidbody2D rb;
    private Vector2 L_fingerDownPosition;
    private Vector2 L_fingerUpPosition;
    private Vector2 R_fingerDownPosition;
    private Vector2 R_fingerUpPosition;
    private float halfScreenWidth;
    private int Rtouch, Ltouch;
 
    [SerializeField] bool detectSwipeOnlyAfterRelease = false;
    [SerializeField] float PlayerSpeed = 10;
    [SerializeField] float SWIPE_THRESHOLD = 20f;
    [SerializeField] GameObject MC;

    private void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        halfScreenWidth = Screen.width / 2;
        Ltouch = -1;
        Rtouch = -1;
    }

    private void Update()
    {
        Touch();
    }

    private void Touch()
    {
        for(int i = 0; i < Input.touchCount; i++)
        {
            //for every touch 'i' input is stored in 't'
            Touch t = Input.GetTouch(i);

            //if touch is in left side of the screen
            if (t.position.x < halfScreenWidth && Ltouch==-1)
            {
                switch (t.phase)
                {
                    case TouchPhase.Began:
                        L_fingerUpPosition = t.position;
                        L_fingerDownPosition = t.position;
                        Debug.Log("Start tracking the Left finger");
                        break;
                    case TouchPhase.Moved:
                        if (!detectSwipeOnlyAfterRelease)
                        {
                            L_fingerDownPosition = t.position;
                            L_DetectSwipe();
                        }
                        break;
                    case TouchPhase.Ended:
                    case TouchPhase.Canceled:
                        L_fingerDownPosition = t.position;
                        L_DetectSwipe();
                        Ltouch = -1;
                        Debug.Log("Stopped tracking left finger");
                        break;
                }
            }
            //if touch is in right side of the screen
            else if (t.position.x > halfScreenWidth && Rtouch==-1) 
            {
                switch (t.phase)
                {
                    case TouchPhase.Began:
                        R_fingerUpPosition = t.position;
                        R_fingerDownPosition = t.position;
                        Debug.Log("Start tracking the Right finger");
                        break;
                    case TouchPhase.Moved:
                        if (!detectSwipeOnlyAfterRelease)
                        {
                            R_fingerDownPosition = t.position;
                            R_DetectSwipe();
                        }
                        break;
                    case TouchPhase.Ended:
                    case TouchPhase.Canceled:
                        R_fingerDownPosition = t.position;
                        R_DetectSwipe();
                        Rtouch = -1;
                        Debug.Log("Stopped tracking right finger");
                        break;
                }
            }
        }
    }

    //============================ LEFT TOUCH ============================//
    private void L_DetectSwipe()
    {
        if (L_horizontalValMove() > SWIPE_THRESHOLD && L_horizontalValMove() > L_verticalMove())
        {
            if (L_fingerDownPosition.x - L_fingerUpPosition.x > 0)//Right swipe
            {
                L_OnSwipeRight();
            }
            else if (L_fingerDownPosition.x - L_fingerUpPosition.x < 0)//Left swipe
            {
                L_OnSwipeLeft();
            }
            L_fingerUpPosition = L_fingerDownPosition;
        }
    }

    float L_verticalMove()
    {
        return Mathf.Abs(L_fingerDownPosition.y - L_fingerUpPosition.y);
    }

    float L_horizontalValMove()
    {
        return Mathf.Abs(L_fingerDownPosition.x - L_fingerUpPosition.x);
    }

    //============================ ON SWIPE (L) ============================//
    void L_OnSwipeLeft()
    {
        MC.transform.Translate(Vector2.left * 5 * Time.deltaTime);
        Debug.Log("Swipe Left");
    }

    void L_OnSwipeRight()
    {
        MC.transform.Translate(Vector2.right * 5 * Time.deltaTime);
        Debug.Log("Swipe Right");
    }
    //======================================================================//

    //============================ RIGHT TOUCH ============================//
    private void R_DetectSwipe()
    {
        // Check if Vertical swipe
        if (R_verticalMove() > SWIPE_THRESHOLD && R_verticalMove() > R_horizontalValMove())
        {
            if (R_fingerDownPosition.y - R_fingerUpPosition.y > 0)//up swipe
            {
                R_OnSwipeUp();
            }
            else if (R_fingerDownPosition.y - R_fingerUpPosition.y < 0)//Down swipe
            {
                R_OnSwipeDown();
            }
            R_fingerUpPosition = R_fingerDownPosition;
        }

        //Check if Horizontal swipe
        else if (R_horizontalValMove() > SWIPE_THRESHOLD && R_horizontalValMove() > R_verticalMove())
        {
            if (R_fingerDownPosition.x - R_fingerUpPosition.x > 0)//Right swipe
            {
                R_OnSwipeRight();
            }
            else if (R_fingerDownPosition.x - R_fingerUpPosition.x < 0)//Left swipe
            {
                R_OnSwipeLeft();
            }
            R_fingerUpPosition = R_fingerDownPosition;
        }
    }

    float R_verticalMove()
    {
        return Mathf.Abs(R_fingerDownPosition.y - R_fingerUpPosition.y);
    }

    float R_horizontalValMove()
    {
        return Mathf.Abs(R_fingerDownPosition.x - R_fingerUpPosition.x);
    }

    //============================ ON SWIPE (R) ============================//
    void R_OnSwipeUp()
    {
        //Jump up
        Debug.Log("Swipe UP");
    }

    void R_OnSwipeDown()
    {
        //Jump Down
        Debug.Log("Swipe Down");
    }

    void R_OnSwipeLeft()
    {
        //Dash left
        Debug.Log("Swipe Left");
    }

    void R_OnSwipeRight()
    {
        //Dash Right
        Debug.Log("Swipe Right");
    }
    //======================================================================//
}

Проблема, с которой я столкнулся прямо сейчас, заключается в том, что когда я смахиваю вправо / влево, он перемещает моего игрока, но выступает один раз за каждое движение. Я хочу, чтобы когда я смахиваю и удерживаю влево или вправо, мой игрок продолжает двигаться. Кроме того, я хочу, чтобы мой персонаж переходил от скорости ходьбы к скорости бега в соответствии с порогом смахивания.