آموزش تخصصی Unity 6 و C#

آموزش ساخت جوی‌استیک لمسی در Unity 6؛ پیاده‌سازی کنترل بازی موبایل با Input System

یکی از مهم‌ترین بخش‌های ساخت بازی موبایل، طراحی سیستم کنترل بازیکن است. ممکن است یک بازی از نظر گرافیکی فوق‌العاده باشد، اما اگر بازیکن نتواند به‌راحتی حرکت کند، بپرد، حمله کند یا دوربین را کنترل کند، تجربه مناسبی نخواهد داشت. به همین دلیل، پیاده‌سازی جوی‌استیک مجازی و کنترل لمسی از مهارت‌های مهم در توسعه بازی‌های اندروید و iOS محسوب می‌شود.

در این آموزش یاد می‌گیریم چگونه در Unity 6 یک سیستم کنترل لمسی ایجاد کنیم که شامل جوی‌استیک مجازی برای حرکت بازیکن و دکمه‌ای برای پرش باشد. علاوه بر آن، با استفاده از سیستم جدید Input System، ورودی کیبورد و کنترل لمسی را در یک ساختار مشترک مدیریت می‌کنیم.

در پایان آموزش، می‌توانید همین ساختار را توسعه دهید و دکمه‌هایی برای شلیک، حمله، تعامل با اشیا، دویدن، نشستن یا استفاده از قابلیت‌های ویژه به بازی اضافه کنید.

جوی‌استیک مجازی چیست و چگونه کار می‌کند؟

جوی‌استیک مجازی یا Virtual Joystick یک کنترل گرافیکی روی صفحه است که حرکت انگشت بازیکن را به ورودی حرکتی تبدیل می‌کند. در بازی‌های موبایل معمولاً این کنترل در قسمت پایین و سمت چپ صفحه قرار می‌گیرد و بازیکن با کشیدن انگشت در جهت‌های مختلف، شخصیت بازی را حرکت می‌دهد.

برای مثال، اگر انگشت به سمت بالا حرکت کند، بازیکن به جلو می‌رود. اگر انگشت به سمت راست کشیده شود، جهت حرکت به راست تغییر می‌کند. در حالت مورب نیز دو مؤلفه افقی و عمودی به‌صورت هم‌زمان دریافت می‌شوند.

جوی‌استیک حرکتی

برای حرکت در چهار یا هشت جهت، کنترل شخصیت، هدایت وسایل نقلیه و حرکت در محیط سه‌بعدی استفاده می‌شود.

دکمه لمسی

برای پرش، شلیک، حمله، تعامل با اشیا، باز کردن درها و فعال کردن قابلیت‌های بازی کاربرد دارد.

ناحیه چرخش دوربین

بازیکن با کشیدن انگشت روی بخش مشخصی از صفحه، زاویه دید دوربین را تغییر می‌دهد.

ورودی چندلمسی

به بازیکن اجازه می‌دهد هم‌زمان حرکت کند، دوربین را بچرخاند و دکمه پرش یا شلیک را فشار دهد.

نکته مهم: جوی‌استیک مجازی صرفاً یک تصویر روی صفحه نیست. این کنترل باید حرکت انگشت را دریافت کند، مقدار آن را به یک ورودی دوبعدی تبدیل کند و نتیجه را به سیستم کنترل شخصیت ارسال کند.

آشنایی با Input System در Unity 6

Unity دو راهکار ورودی دارد: سیستم قدیمی Input Manager و سیستم جدید Input System. در این آموزش از Input System استفاده می‌کنیم؛ زیرا امکان تعریف اکشن‌های ورودی، اتصال چند دستگاه به یک اکشن و مدیریت کنترل‌های روی صفحه را فراهم می‌کند.

به‌جای آنکه منطق بازی مستقیماً به کلیدهای مشخصی مانند W یا Space وابسته باشد، اکشن‌هایی مانند Move و Jump تعریف می‌کنیم. سپس مشخص می‌کنیم هر اکشن از کدام ورودی‌ها مقدار دریافت کند.

مفهوم	کاربرد
Input Action	تعریف یک عمل مانند حرکت، پرش یا شلیک.
Binding	اتصال اکشن به ورودی‌هایی مانند کیبورد، گیم‌پد یا کنترل لمسی.
Value	دریافت مقدار پیوسته مانند بردار دوبعدی حرکت.
Button	دریافت وضعیت فشرده شدن یک دکمه.
OnScreenStick	تبدیل تعامل با جوی‌استیک روی صفحه به ورودی مجازی.
OnScreenButton	تبدیل لمس یک دکمه روی صفحه به ورودی دکمه‌ای مجازی.

مزیت مهم این معماری آن است که اکشن Move می‌تواند هم از کیبورد و هم از جوی‌استیک مجازی ورودی دریافت کند. بنابراین، نیازی نیست برای هر روش کنترل، سیستم حرکتی جداگانه‌ای بنویسیم.

مستندات رسمی این سیستم را در راهنمای Input System مطالعه کنید. نسخه نصب‌شده در پروژه شما ممکن است متفاوت باشد؛ در نتیجه، نسخه پکیج و مستندات متناظر با آن را مبنا قرار دهید.

مرحله اول: نصب و فعال‌سازی Input System در Unity 6

گام اول: باز کردن Package Manager

در Unity Editor از منوی Window وارد Package Management شوید و Package Manager را باز کنید. سپس در فهرست پکیج‌ها، Input System را جست‌وجو کنید.

گام دوم: نصب Input System

پکیج Input System را انتخاب کنید و در صورت نصب نبودن، آن را نصب کنید. از نصب نسخه سازگار با نسخه Unity پروژه خود اطمینان حاصل کنید.

گام سوم: فعال کردن سیستم ورودی جدید

وارد مسیر Edit، سپس Project Settings و بخش Player شوید. در قسمت Other Settings، تنظیم Active Input Handling را پیدا کنید.

گزینه Input System Package (New) را انتخاب کنید. اگر پروژه به هر دو سیستم نیاز دارد، می‌توانید گزینه Both را در نظر بگیرید؛ اما برای این آموزش نیازی به استفاده از API قدیمی نداریم.

ممکن است Unity برای اعمال تغییرات درخواست راه‌اندازی مجدد Editor را نمایش دهد. در این صورت، Editor را مجدداً راه‌اندازی کنید.

توجه: در پروژه‌های موجود، تغییر سیستم ورودی می‌تواند بر اسکریپت‌هایی که از API قدیمی استفاده می‌کنند اثر بگذارد. اگر در کدهای پروژه از UnityEngine.Input استفاده شده است، آن بخش‌ها را جداگانه بررسی کنید.

مرحله دوم: ساخت Input Actions برای حرکت و پرش

در این مرحله دو اکشن اصلی می‌سازیم: Move برای حرکت و Jump برای پرش. هر دو اکشن از چند نوع ورودی پشتیبانی خواهند کرد.

گام اول: ایجاد فایل Input Actions

در پنجره Project روی فضای خالی کلیک راست کنید و از مسیر Create، بخش Input Actions را انتخاب کنید. نام فایل را PlayerControls قرار دهید.

گام دوم: ساخت Action Map

فایل را باز کنید و یک Action Map با نام Player بسازید. سپس دو اکشن زیر را اضافه کنید.

Move: نوع Value و کنترل مورد انتظار Vector2.
Jump: نوع Button.

گام سوم: تنظیم ورودی حرکت

برای اکشن Move یک Binding از نوع 2D Vector Composite بسازید و کلیدهای زیر را تنظیم کنید:

Up: کلید W
Down: کلید S
Left: کلید A
Right: کلید D

سپس یک Binding دیگر برای مسیر <Gamepad>/leftStick اضافه کنید. این Binding بعداً ورودی جوی‌استیک مجازی را نیز دریافت خواهد کرد.

گام چهارم: تنظیم ورودی پرش

برای اکشن Jump، کلید Space را به‌عنوان ورودی کیبورد تعریف کنید. سپس Binding دیگری با مسیر <Gamepad>/buttonSouth اضافه کنید.

دکمه پرش لمسی را نیز به همین مسیر متصل خواهیم کرد. در نتیجه، کیبورد، گیم‌پد و دکمه لمسی می‌توانند اکشن مشترک Jump را فعال کنند.

چرا از مسیرهای Gamepad استفاده می‌کنیم؟ چون کنترل‌های OnScreen در این آموزش یک گیم‌پد مجازی ایجاد می‌کنند. جوی‌استیک مجازی مقدار leftStick را ارسال می‌کند و دکمه پرش مقدار buttonSouth را تغییر می‌دهد. اکشن‌های بازی این ورودی‌ها را مانند ورودی گیم‌پد دریافت می‌کنند.

در این روش از تولید کد خودکار Input Actions استفاده نمی‌کنیم؛ بنابراین برای اجرای اسکریپت‌ها به کلاس تولیدشده‌ای با نام خاص نیاز ندارید.

مرحله سوم: ساخت سیستم حرکت بازیکن با C#

اکنون یک اسکریپت می‌نویسیم که مقدار اکشن Move را دریافت کند، شخصیت را حرکت دهد و پرش را مدیریت کند. برای حرکت شخصیت از CharacterController استفاده می‌کنیم تا پیاده‌سازی ساده و قابل توسعه باشد.

این نمونه برای یک شخصیت سه‌بعدی طراحی شده است. حرکت روی محورهای افقی انجام می‌شود و گرانش و پرش روی محور عمودی مدیریت می‌شوند.

کد کامل اسکریپت MobilePlayerController.cs

using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(CharacterController))]
public class MobilePlayerController : MonoBehaviour
{
    [Header("Input Actions")]
    [SerializeField] private InputActionReference moveAction;
    [SerializeField] private InputActionReference jumpAction;

    [Header("Movement")]
    [SerializeField, Min(0f)] private float moveSpeed = 5f;
    [SerializeField, Min(0f)] private float jumpHeight = 1.5f;
    [SerializeField, Min(0f)] private float gravity = 20f;

    private CharacterController characterController;
    private Vector3 verticalVelocity;
    private bool jumpRequested;

    private void Awake()
    {
        characterController = GetComponent<CharacterController>();
    }

    private void OnEnable()
    {
        if (moveAction != null)
            moveAction.action.Enable();

        if (jumpAction != null)
        {
            jumpAction.action.performed += OnJumpPerformed;
            jumpAction.action.Enable();
        }
    }

    private void OnDisable()
    {
        if (jumpAction != null)
        {
            jumpAction.action.performed -= OnJumpPerformed;
            jumpAction.action.Disable();
        }

        if (moveAction != null)
            moveAction.action.Disable();
    }

    private void OnJumpPerformed(InputAction.CallbackContext context)
    {
        jumpRequested = true;
    }

    private void Update()
    {
        if (moveAction == null || jumpAction == null)
            return;

        Vector2 input =
            moveAction.action.ReadValue<Vector2>();

        Vector3 horizontalMovement = new Vector3(
            input.x,
            0f,
            input.y
        );

        horizontalMovement = Vector3.ClampMagnitude(
            horizontalMovement,
            1f
        );

        characterController.Move(
            horizontalMovement * moveSpeed * Time.deltaTime
        );

        if (characterController.isGrounded &&
            verticalVelocity.y < 0f)
        {
            verticalVelocity.y = -2f;
        }

        if (jumpRequested &&
            characterController.isGrounded)
        {
            verticalVelocity.y = Mathf.Sqrt(
                jumpHeight * 2f * gravity
            );
        }

        jumpRequested = false;

        verticalVelocity.y -= gravity * Time.deltaTime;

        characterController.Move(
            verticalVelocity * Time.deltaTime
        );
    }
}

بررسی بخش‌های مهم کد

InputActionReference: به اکشن‌های تعریف‌شده در فایل Input Actions اشاره می‌کند.
ReadValue<Vector2>: مقدار دوبعدی حرکت را از کیبورد یا جوی‌استیک مجازی دریافت می‌کند.
ClampMagnitude: مقدار بردار حرکت را محدود می‌کند تا حرکت مورب از سرعت مورد انتظار بیشتر نشود.
OnJumpPerformed: هنگام فعال شدن اکشن Jump درخواست پرش را ثبت می‌کند.
CharacterController.Move: حرکت شخصیت را با توجه به برخوردها اعمال می‌کند.
Gravity: نیروی گرانش را برای حرکت عمودی شبیه‌سازی می‌کند.

نکته اجرایی: اسکریپت فرض می‌کند اکشن‌های Move و Jump در یک فایل Input Actions تعریف شده‌اند و کنترل‌های لمسی به مسیرهای Gamepad متصل هستند. همچنین فرض می‌کند این اکشن‌ها به‌صورت مستقل در این اسکریپت مدیریت می‌شوند؛ اگر آن‌ها را از طریق PlayerInput یا یک سیستم مرکزی فعال می‌کنید، مدیریت فعال‌سازی را یکپارچه کنید تا چند بخش مختلف یک اکشن مشترک را فعال و غیرفعال نکنند.

مرحله چهارم: ساخت جوی‌استیک و دکمه لمسی در Unity

در Input System، کامپوننت OnScreenStick منطق تعامل لمسی را فراهم می‌کند؛ اما ظاهر گرافیکی آن را خودتان طراحی می‌کنید. به همین دلیل، باید یک UI مناسب برای پایه جوی‌استیک و بخش متحرک آن بسازید.

گام اول: ساخت Canvas

در Hierarchy روی فضای خالی کلیک راست کنید و از مسیر UI، یک Canvas ایجاد کنید. اگر EventSystem به‌صورت خودکار ایجاد نشده است، آن را نیز اضافه کنید.

در Canvas Scaler، گزینه UI Scale Mode را روی Scale With Screen Size قرار دهید. برای Reference Resolution می‌توانید مقدار 1920×1080 را به‌عنوان نقطه شروع در نظر بگیرید و سپس طراحی را روی چند نسبت تصویر آزمایش کنید.

گام دوم: ساخت ظاهر جوی‌استیک

درون Canvas یک Image برای پایه جوی‌استیک و یک Image فرزند برای دسته متحرک ایجاد کنید. برای هرکدام از تصاویر می‌توانید از Sprite دایره‌ای استفاده کنید.

نام اشیا را به این شکل انتخاب کنید:

MobileControls برای Canvas یا بخش کنترل‌های موبایل.
JoystickBase برای پایه جوی‌استیک.
JoystickHandle برای دسته جوی‌استیک.
JumpButton برای دکمه پرش.

پایه جوی‌استیک را در قسمت پایین و سمت چپ صفحه قرار دهید. اندازه پیشنهادی اولیه می‌تواند حدود 180 تا 220 واحد UI باشد؛ این مقدار باید متناسب با رزولوشن، Canvas Scaler و تجربه واقعی روی دستگاه تنظیم شود.

گام سوم: افزودن OnScreenStick

کامپوننت OnScreenStick را به شیء JoystickBase اضافه کنید. در تنظیمات آن، Control Path را روی مسیر زیر قرار دهید:

<Gamepad>/leftStick

گزینه‌های کامپوننت مانند Movement Range و رفتار حرکت دسته را مطابق طراحی خود تنظیم کنید. ظاهر پایه و دسته را می‌توانید با Sprite، رنگ، شفافیت و انیمیشن‌های UI شخصی‌سازی کنید.

در پیاده‌سازی استاندارد OnScreenStick، تعامل از محل شروع لمس مدیریت می‌شود و محدوده حرکت دسته به تنظیمات کامپوننت وابسته است. بنابراین، محل شروع لمس الزاماً به مرکز ثابت تصویر جوی‌استیک محدود نمی‌شود؛ رفتار دقیق را در نسخه پکیج نصب‌شده بررسی کنید.

گام چهارم: ساخت دکمه پرش

یک Image یا Button در بخش پایین و سمت راست صفحه بسازید. اندازه و فاصله آن را طوری تنظیم کنید که بازیکن بتواند بدون برخورد با سایر کنترل‌ها آن را لمس کند.

کامپوننت OnScreenButton را به همان شیء کنترل اضافه کنید و Control Path را روی مسیر زیر قرار دهید:

<Gamepad>/buttonSouth

در این مثال، Button فقط ظاهر گرافیکی است و OnScreenButton ورودی را ارسال می‌کند. اگر از کامپوننت Button استاندارد UI نیز استفاده می‌کنید، بررسی کنید که رویدادهای کلیک آن با رفتار OnScreenButton تداخل نداشته باشند.

تفاوت مهم: لازم نیست برای دریافت ورودی جوی‌استیک، یک اسکریپت جداگانه بنویسید که هر فریم موقعیت انگشت را محاسبه کند. OnScreenStick این وظیفه را انجام می‌دهد و مقدار را به ورودی مجازی متصل به مسیر انتخاب‌شده می‌فرستد.

مرحله پنجم: اتصال کنترل‌های لمسی به بازی

اکنون باید اشیای ساخته‌شده در صحنه را به اسکریپت کنترل بازیکن و اکشن‌های ورودی متصل کنیم.

گام اول: آماده‌سازی بازیکن

یک GameObject برای بازیکن بسازید یا مدل سه‌بعدی خود را وارد کنید. کامپوننت CharacterController را به آن اضافه کنید و اسکریپت MobilePlayerController را روی همان شیء قرار دهید.

گام دوم: اتصال اکشن Move

در Inspector اسکریپت، فیلد Move Action را باز کنید و اکشن Move از Action Map مربوط به Player را انتخاب کنید.

گام سوم: اتصال اکشن Jump

اکشن Jump را نیز در فیلد Jump Action قرار دهید. این اکشن باید ورودی Space و مسیر Gamepad buttonSouth را داشته باشد.

گام چهارم: بررسی EventSystem

برای کار کردن تعاملات UI با Input System جدید، بررسی کنید که EventSystem از InputSystemUIInputModule استفاده کند. اگر هنوز StandaloneInputModule فعال است، تنظیمات آن را متناسب با سیستم ورودی جدید اصلاح کنید.

گام پنجم: بررسی Canvas و کنترل‌ها

اطمینان حاصل کنید JoystickBase و JumpButton درون Canvas فعال قرار دارند، کامپوننت‌های OnScreen فعال‌اند و مسیرهای ورودی دقیقاً مطابق Input Actions تنظیم شده‌اند.

پس از این مراحل، حرکت با WASD و جوی‌استیک مجازی باید به یک اکشن مشترک برسد و Space و دکمه پرش نیز اکشن Jump را فعال کنند.

مرحله ششم: حرکت دوربین با لمس صفحه

در بسیاری از بازی‌های سه‌بعدی موبایل، کنترل حرکت بازیکن به‌تنهایی کافی نیست. بازیکن باید بتواند با کشیدن انگشت در بخش مشخصی از صفحه، دوربین را نیز بچرخاند.

برای پیاده‌سازی این قابلیت، بهتر است اکشن جداگانه‌ای مانند Look با نوع Value و کنترل مورد انتظار Vector2 تعریف کنید. سپس آن را به ورودی مناسب ماوس یا کنترل لمسی سفارشی متصل کنید.

برای طراحی ساده‌تر، می‌توانید یک ناحیه UI شفاف در سمت راست صفحه ایجاد کنید و حرکت انگشت را فقط در آن ناحیه دریافت کنید. در این حالت باید شناسه هر لمس را به‌درستی مدیریت کنید تا انگشتی که جوی‌استیک را کنترل می‌کند به‌طور هم‌زمان برای چرخش دوربین استفاده نشود.

اگر از Touchscreen و Input Actions مستقیم استفاده می‌کنید، توجه داشته باشید که چندلمسی به مدیریت چند تماس مستقل نیاز دارد. اتصال یک جوی‌استیک مجازی به مسیر Gamepad و استفاده از یک اکشن جداگانه برای نگاه کردن، معمولاً ساختار قابل‌نگهداری‌تری ایجاد می‌کند.

پیشنهاد برای پروژه‌های حرفه‌ای: ورودی حرکت، چرخش دوربین، پرش، شلیک و تعامل را در اکشن‌های مجزا تعریف کنید. این کار توسعه قابلیت‌هایی مانند تغییر کنترل‌ها، پشتیبانی از گیم‌پد فیزیکی و تنظیمات شخصی‌سازی را ساده‌تر می‌کند.

مرحله هفتم: آزمایش کنترل لمسی در Unity

پس از تکمیل کنترل‌ها، باید عملکرد آن‌ها را بررسی کنید. اجرای بازی در Editor برای آزمایش اولیه مفید است؛ اما شبیه‌سازی ماوس به‌تنهایی جای آزمایش چندلمسی واقعی روی دستگاه موبایل را نمی‌گیرد.

بررسی کنید که حرکت با WASD همچنان کار می‌کند.
جوی‌استیک را در جهات مختلف حرکت دهید و مقدار حرکت را بررسی کنید.
بررسی کنید که هنگام رها کردن انگشت، ورودی حرکت به حالت خنثی برگردد.
دکمه پرش را چند بار فشار دهید و رفتار پرش روی زمین و در هوا را بررسی کنید.
حرکت هم‌زمان و فشردن دکمه پرش را آزمایش کنید.
روی دستگاه واقعی، چرخش صفحه و نسبت تصویر را بررسی کنید.
عملکرد کنترل‌ها را با چند لمس هم‌زمان آزمایش کنید.

برای ساخت نسخه اندروید، از Build Profiles یا تنظیمات Build متناسب با نسخه Unity خود استفاده کنید. سپس پروژه را روی دستگاه واقعی اجرا کنید و تأخیر ورودی، اندازه دکمه‌ها، مصرف باتری و عملکرد کلی بازی را بررسی کنید.

مستندات رسمی Unity درباره ورودی در اندروید و ورودی در iOS اطلاعات تکمیلی درباره پشتیبانی از ورودی‌های دستگاه ارائه می‌کنند.

نکات حرفه‌ای برای طراحی کنترل لمسی بازی موبایل

۱. اندازه دکمه‌ها را برای انگشت طراحی کنید

کنترل‌های موبایل نباید بیش از حد کوچک باشند. اندازه ظاهری، فاصله دکمه‌ها و محل قرارگیری آن‌ها را روی دستگاه واقعی بررسی کنید. اندازه مناسب به سبک بازی، رزولوشن، نسبت تصویر و نوع کنترل بستگی دارد.

۲. از طراحی مقیاس‌پذیر استفاده کنید

از Anchorهای مناسب و Canvas Scaler استفاده کنید تا کنترل‌ها روی نمایشگرهای مختلف در جای صحیح باقی بمانند. قرار دادن دکمه‌ها صرفاً با مختصات ثابت ممکن است در برخی نسبت‌های تصویر مشکل ایجاد کند.

۳. حرکت مورب را کنترل کنید

اگر مقدار ورودی را بدون محدود کردن اندازه بردار استفاده کنید، ممکن است حرکت مورب سریع‌تر از حرکت مستقیم باشد. استفاده از ClampMagnitude یا پردازش مناسب ورودی، این مشکل را کاهش می‌دهد.

۴. رفتار لمس و رها کردن انگشت را بررسی کنید

پس از رها شدن انگشت، جوی‌استیک باید به حالت خنثی برگردد. همچنین در صورت لغو لمس توسط سیستم‌عامل، کنترل نباید برای مدت طولانی در وضعیت فشرده باقی بماند.

۵. ورودی حرکت را از منطق بازی جدا کنید

اکشن‌های Input System باید ورودی را دریافت کنند و منطق بازی باید بر اساس آن تصمیم بگیرد. این جداسازی امکان تغییر دستگاه ورودی بدون بازنویسی کامل کنترل شخصیت را فراهم می‌کند.

۶. برای دوربین و حرکت، ناحیه‌های جداگانه در نظر بگیرید

در بازی‌های اکشن، بهتر است ناحیه کنترل حرکت از ناحیه چرخش دوربین جدا باشد. این کار از تداخل ورودی‌ها جلوگیری می‌کند و یادگیری کنترل بازی را ساده‌تر می‌سازد.

۷. عملکرد واقعی را روی دستگاه آزمایش کنید

کیفیت تجربه لمسی تنها به اجرای صحیح کد وابسته نیست. تأخیر ورودی، نرخ فریم، اندازه صفحه، حساسیت کنترل و قابلیت استفاده در شرایط مختلف باید در نسخه واقعی بازی بررسی شوند.

رفع خطاهای رایج در ساخت جوی‌استیک لمسی Unity

جوی‌استیک نمایش داده می‌شود اما بازیکن حرکت نمی‌کند

Control Path کامپوننت OnScreenStick را بررسی کنید. مطمئن شوید مسیر آن <Gamepad>/leftStick است، اکشن Move به مسیر <Gamepad>/leftStick متصل شده و اکشن در زمان اجرای بازی فعال است.

دکمه پرش کار نمی‌کند

مسیر OnScreenButton باید با Binding اکشن Jump مطابقت داشته باشد. در این آموزش هر دو از <Gamepad>/buttonSouth استفاده می‌کنند. همچنین بررسی کنید که کامپوننت OnScreenButton فعال باشد.

خطای مربوط به Input System مشاهده می‌شود

نصب پکیج، نسخه آن، تنظیم Active Input Handling و ارجاع‌های Input Actions را بررسی کنید. اگر کد دیگری در پروژه از API قدیمی استفاده می‌کند، آن کد نیز ممکن است نیازمند اصلاح باشد.

کنترل‌ها در Editor کار می‌کنند اما روی موبایل مشکل دارند

روی دستگاه واقعی آزمایش کنید. ورودی چندلمسی، تنظیمات پلتفرم، Canvas Scaler، نسبت تصویر و EventSystem را بررسی کنید. شبیه‌سازی ماوس نمی‌تواند تمام رفتارهای صفحه لمسی را بازسازی کند.

هنگام لمس جوی‌استیک، رابط کاربری دیگری هم فعال می‌شود

ترتیب لایه‌های UI، Raycast Target تصاویر و نحوه مدیریت رویدادهای Pointer را بررسی کنید. در کنترل‌های سفارشی، شناسه لمس و محدوده دریافت ورودی باید به‌درستی مدیریت شوند.

سؤالات متداول درباره جوی‌استیک لمسی در Unity

چگونه در Unity 6 جوی‌استیک لمسی بسازیم؟

ابتدا Input System را نصب و فعال کنید، سپس یک کنترل UI با ظاهر جوی‌استیک بسازید و کامپوننت OnScreenStick را به آن اضافه کنید. Control Path را روی <Gamepad>/leftStick قرار دهید و این ورودی را به اکشن Move متصل کنید.

آیا برای ساخت جوی‌استیک موبایل باید کدنویسی کنیم؟

برای ساخت یک جوی‌استیک استاندارد می‌توانید از OnScreenStick استفاده کنید و نیازی به نوشتن الگوریتم کامل تشخیص لمس ندارید. بااین‌حال، برای حرکت شخصیت، پرش، دوربین و مکانیک‌های بازی معمولاً به اسکریپت‌های متناسب با پروژه نیاز خواهید داشت.

آیا Input System از کنترل لمسی اندروید و iOS پشتیبانی می‌کند؟

بله، Input System از ورودی لمسی در پلتفرم‌های موبایل پشتیبانی می‌کند. جزئیات قابلیت‌ها و تنظیمات وابسته به نسخه Unity، پکیج و دستگاه هدف هستند؛ بنابراین، آزمایش روی دستگاه واقعی ضروری است.

چگونه حرکت کیبورد و جوی‌استیک را با یک اسکریپت مدیریت کنیم؟

یک اکشن Move با نوع Value و کنترل Vector2 بسازید. برای آن Bindingهای کیبورد و Gamepad تعریف کنید و مقدار خروجی را با ReadValue دریافت کنید. در این صورت، اسکریپت حرکت به یک دستگاه ورودی خاص وابسته نخواهد بود.

چرا OnScreenStick به‌تنهایی بازیکن را حرکت نمی‌دهد؟

OnScreenStick ورودی مجازی تولید می‌کند، اما منطق حرکت شخصیت را اجرا نمی‌کند. باید این ورودی به Input Action مناسب متصل شود و اسکریپت کنترل بازیکن از مقدار آن برای حرکت استفاده کند.

آیا می‌توان هم‌زمان حرکت کرد و دکمه پرش را فشار داد؟

بله. با طراحی صحیح کنترل‌های UI و استفاده از ورودی‌های مجزا می‌توان چند لمس را به‌صورت هم‌زمان مدیریت کرد. این رفتار باید روی دستگاه واقعی آزمایش شود.

آیا برای بازی دوبعدی نیز می‌توان از همین روش استفاده کرد؟

بله، می‌توانید از OnScreenStick و Input System برای بازی‌های دوبعدی نیز استفاده کنید. بااین‌حال، اسکریپت حرکت باید متناسب با Rigidbody2D، برخوردهای دوبعدی و منطق حرکتی بازی تنظیم شود.

جمع‌بندی؛ ساخت کنترل لمسی حرفه‌ای در Unity 6

در این آموزش یاد گرفتیم چگونه با استفاده از Input System در Unity 6 یک سیستم کنترل لمسی برای بازی موبایل طراحی کنیم. با تعریف اکشن‌های Move و Jump، استفاده از OnScreenStick و OnScreenButton و اتصال آن‌ها به اسکریپت C#، می‌توان کنترل حرکت و پرش را بدون وابستگی مستقیم به یک دستگاه ورودی پیاده‌سازی کرد.

مهم‌ترین مزیت این معماری، قابلیت توسعه آن است. در ادامه می‌توانید اکشن‌هایی برای چرخش دوربین، شلیک، حمله، تعامل با اشیا و سایر قابلیت‌های بازی اضافه کنید و در صورت نیاز از کیبورد یا گیم‌پد فیزیکی نیز پشتیبانی کنید.

برای رسیدن به نتیجه حرفه‌ای، کنترل‌ها را فقط در Editor آزمایش نکنید. بازی را روی دستگاه واقعی اجرا کنید، اندازه و محل دکمه‌ها را بهینه کنید و عملکرد چندلمسی را بررسی کنید.

قدم بعدی: پس از پیاده‌سازی حرکت و پرش، سیستم کنترل دوربین را اضافه کنید و سپس کنترل‌ها را برای سبک بازی خود، از جمله اکشن، ماجراجویی یا نقش‌آفرینی، شخصی‌سازی کنید.

آموزش جوی‌استیک لمسی در Unity 6 + کد #C