Start Unity

درود به همه دوستان عزیز! از این پس محتوای کانال ما متنوع‌تر خواهد شد. علاوه بر آموزش‌های برنامه‌نویسی، پست‌های جذاب درباره ایده‌پردازی و طراحی بازی هم خواهیم داشت. امروز می‌خواهیم نگاهی به دنیای بازی‌های ویدیویی بیندازیم. بازی‌های ویدیویی: از دهه 70 میلادی، بازی‌های ویدیویی وارد زندگی ما شدند و از آن زمان تاکنون تحولات زیادی را پشت سر گذاشته‌اند. اولین بازی‌ها مانند Pong و Space Invaders پایه‌گذار صنعت بازی‌های ویدیویی بودند. با پیشرفت فناوری، بازی‌ها نیز پیچیده‌تر و جذاب‌تر شدند، از بازی‌های ساده دو بعدی به دنیای سه‌بعدی با گرافیک بالا و داستان‌های عمیق. انواع سبک‌های بازی‌های ویدیویی: اکشن (Action): بازی‌های اکشن بر اساس سرعت و واکنش سریع بازیکن‌ها طراحی شده‌اند. نمونه‌هایی مانند Call of Duty و Devil May Cry با حرکات سریع و مبارزات هیجان‌انگیز شناخته می‌شوند. این بازی‌ها معمولاً نیاز به مهارت‌های بالای حرکتی دارند. ماجراجویی (Adventure): این بازی‌ها بر داستان و کاوش تأکید دارند. بازی‌های معروفی مثل The Legend of Zelda و Uncharted بازیکن‌ها را به دنیای‌های وسیع و پر از معماهای مختلف می‌برند. تجربه داستانی قوی و گیم‌پلی متنوع از ویژگی‌های این سبک است. نقش‌آفرینی (RPG): بازی‌های نقش‌آفرینی به بازیکن‌ها امکان می‌دهند تا شخصیت‌های خود را با قابلیت‌ها و مهارت‌های مختلف سفارشی کنند. بازی‌هایی مانند Final Fantasy و The Witcher با داستان‌های عمیق و سیستم‌های پیچیده نقش‌آفرینی شناخته می‌شوند. ورزشی (Sports): این بازی‌ها مسابقات ورزشی واقعی را شبیه‌سازی می‌کنند. FIFA و NBA 2K از محبوب‌ترین بازی‌های ورزشی هستند که تجربه‌ای واقعی از مسابقات ورزشی را ارائه می‌دهند. استراتژی (Strategy): در این سبک بازی‌ها، بازیکن‌ها باید با برنامه‌ریزی و مدیریت منابع بر دشمنان خود غلبه کنند. بازی‌هایی مثل StarCraft و Age of Empires از معروف‌ترین نمونه‌های بازی‌های استراتژی هستند که نیاز به تفکر و استراتژی دارند. شبیه‌سازی (Simulation): این بازی‌ها سعی دارند تا واقعیت را شبیه‌سازی کنند، مانند The Sims که زندگی روزمره را شبیه‌سازی می‌کند یا Flight Simulator که تجربه پرواز را ارائه می‌دهد. مبارزه‌ای (Fighting): در این سبک، بازیکن‌ها در مسابقات تن به تن با یکدیگر مبارزه می‌کنند. بازی‌هایی مانند Street Fighter و Mortal Kombat از مشهورترین بازی‌های مبارزه‌ای هستند. پازل (Puzzle): این بازی‌ها بر حل معما و چالش‌های ذهنی تمرکز دارند. بازی‌هایی مانند Tetris و Candy Crush نمونه‌های معروف این سبک هستند. مسابقه‌ای (Racing): بازی‌های مسابقه‌ای به بازیکن‌ها امکان مسابقه دادن با وسایل نقلیه مختلف را می‌دهند. بازی‌هایی مانند Need for Speed و Gran Turismo در این دسته قرار می‌گیرند. ترس و بقا (Horror and Survival): این بازی‌ها بازیکن‌ها را در موقعیت‌های ترسناک و چالش‌برانگیز قرار می‌دهند که باید برای بقا تلاش کنند. Resident Evil و Silent Hill از نمونه‌های بارز این سبک هستند. موسیقی و ریتم (Music and Rhythm): این بازی‌ها بر اساس موسیقی و ریتم طراحی شده‌اند و بازیکن‌ها باید با دقت به موسیقی واکنش نشان دهند. بازی‌هایی مانند Guitar Hero و Dance Dance Revolution از این دسته‌اند. مبارزات آنلاین چندنفره (MOBA): این بازی‌ها شامل مسابقات چند نفره آنلاین هستند که بازیکن‌ها با تیم‌های خود در مقابل یکدیگر قرار می‌گیرند. بازی‌های معروفی مانند League of Legends و Dota 2 در این دسته قرار دارند. هر سبک بازی تجربه‌ای منحصربه‌فرد را ارائه می‌دهد و شما را به دنیای جدیدی می‌برد. پس همراه ما باشید و از محتوای متنوع کانال لذت ببرید! در پست‌های بعدی به جزئیات بیشتری درباره هر سبک و نمونه‌های موفق خواهیم پرداخت. #بازی_ویدیویی #یونیتی #ایده_پردازی #توسعه_بازی #آموزش_بازی #سبک_بازی #اکشن #ماجراجویی #نقش_آفرینی #ورزشی #استراتژی #شبیه‌سازی #مبارزه‌ای #پازل #مسابقه‌ای #ترس_و_بقا #موسیقی_و_ریتم #MOBA

دوستان عزیز 🌟 من مدت زیادی هست که با عشق و علاقه در کانال Start Unity فعالیت می‌کنم و آموزش‌های متنی و کدهای یونیتی رو با شما به اشتراک می‌گذارم. از حمایت‌های شما بسیار ممنونم. اما برای اینکه کانال بتونه رشد بیشتری داشته باشه و بتونم مطالب بیشتری براتون آماده کنم، به حمایت‌های شما نیاز دارم. خواهشمندم که پست‌های کانال رو با دوستان و همکارانتون به اشتراک بذارید تا اعضای کانال افزایش پیدا کنه. همچنین می‌خواهم از دوست عزیزم که کانال رو بوست کرد، تشکر ویژه کنم. حمایت تو برای من بسیار ارزشمنده ❤️ به عنوان تشکر از حمایت‌های شما، در آینده قصد دارم آموزش‌های ویدیویی یونیتی هم بسازم و در کانال قرار بدم. از همراهی و حمایت‌های شما بسیار سپاسگزارم. با هم می‌تونیم این کانال رو به یکی از بهترین منابع آموزشی یونیتی تبدیل کنیم 🚀

یونیتی ایونت‌ها (UnityEvents) در یونیتی یونیتی ایونت‌ها نوعی سیستم رویداد در یونیتی هستند که به شما اجازه می‌دهند به سادگی کدهای خود را به رویدادهای مختلف متصل کنید، بدون نیاز به نوشتن کدهای پیچیده برای مدیریت این رویدادها. این سیستم به خصوص برای طراحان بازی که ترجیح می‌دهند بیشتر از طریق رابط کاربری یونیتی کار کنند، بسیار مفید است. ### ایجاد و استفاده از یونیتی ایونت #### ۱. ایجاد یونیتی ایونت برای استفاده از یونیتی ایونت، ابتدا باید آن را در یک اسکریپت تعریف کنید.

using UnityEngine;
using UnityEngine.Events;

public class MyEventClass : MonoBehaviour
{
    // تعریف یک یونیتی ایونت
    public UnityEvent myEvent;

    private void Start()
    {
        if (myEvent == null)
            myEvent = new UnityEvent();

        // اضافه کردن یک لیسنر به یونیتی ایونت
        myEvent.AddListener(Ping);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // فراخوانی یونیتی ایونت
            myEvent.Invoke();
        }
    }

    void Ping()
    {
        Debug.Log("Ping was called!");
    }
}

در این مثال، یک یونیتی ایونت به نام myEvent تعریف شده است. سپس در متد Start`، یک لیسنر به این رویداد اضافه می‌شود که در هنگام فراخوانی رویداد، متد `Ping را اجرا می‌کند. در متد Update`، اگر کلید Space فشرده شود، رویداد `myEvent فراخوانی می‌شود و در نتیجه Ping اجرا می‌شود. #### ۲. استفاده از یونیتی ایونت با پارامتر یونیتی ایونت می‌تواند از انواع مختلفی از پارامترها استفاده کند. برای این کار، باید نوع یونیتی ایونت را مشخص کنید.

using UnityEngine;
using UnityEngine.Events;

[System.Serializable]
public class MyFloatEvent : UnityEvent<float> { }

public class MyEventClass : MonoBehaviour
{
    public MyFloatEvent myFloatEvent;

    private void Start()
    {
        if (myFloatEvent == null)
            myFloatEvent = new MyFloatEvent();

        myFloatEvent.AddListener(Ping);
    }

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            myFloatEvent.Invoke(3.14f);
        }
    }

    void Ping(float value)
    {
        Debug.Log("Ping was called with value: " + value);
    }
}

در این مثال، یک یونیتی ایونت با پارامتر float به نام myFloatEvent تعریف شده است. سپس یک لیسنر به این رویداد اضافه می‌شود که هنگام فراخوانی رویداد، متد Ping را با یک مقدار float اجرا می‌کند. #### ۳. تنظیم یونیتی ایونت در اینسپکتور برای تنظیم یونیتی ایونت در اینسپکتور، باید ابتدا مطمئن شوید که کلاس حاوی یونیتی ایونت با [System.Serializable] تزئین شده است.

using UnityEngine;
using UnityEngine.Events;

public class MyEventClass : MonoBehaviour
{
    [System.Serializable]
    public class MyCustomEvent : UnityEvent<string> { }

    public MyCustomEvent myCustomEvent;

    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            myCustomEvent.Invoke("Hello, World!");
        }
    }
}

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

متدهای کلاس Physics در Unity برای انجام عملیات فیزیکی مختلف استفاده می‌شوند. این متدها به شما اجازه می‌دهند که اشیاء را در جهان سه‌بعدی بازی جستجو کرده، برخوردها را مدیریت کرده و شبیه‌سازی‌های فیزیکی را انجام دهید. در اینجا برخی از مهمترین متدهای کلاس Physics به همراه توضیحات و مثال‌های کاربردی آورده شده‌اند: ### 1. Raycast پرتاب یک پرتو از یک نقطه مشخص در یک جهت خاص و بررسی برخورد آن با اشیاء.

void Update()
{
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit hit;
    if (Physics.Raycast(ray, out hit, 100))
    {
        Debug.Log("Hit: " + hit.collider.name);
    }
}

### 2. RaycastAll پرتاب یک پرتو و بازگرداندن تمام برخوردهایی که با اشیاء داشته است.

void Update()
{
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit[] hits = Physics.RaycastAll(ray, 100);
    foreach (RaycastHit hit in hits)
    {
        Debug.Log("Hit: " + hit.collider.name);
    }
}

### 3. SphereCast پرتاب یک کره از یک نقطه مشخص در یک جهت خاص و بررسی برخورد آن با اشیاء.

void Update()
{
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit hit;
    if (Physics.SphereCast(ray, 1.0f, out hit, 100))
    {
        Debug.Log("Hit: " + hit.collider.name);
    }
}

### 4. OverlapSphere بازگرداندن تمام اشیایی که در داخل یک کره با شعاع مشخص قرار دارند.

void Update()
{
    Collider[] hitColliders = Physics.OverlapSphere(transform.position, 5.0f);
    foreach (Collider hitCollider in hitColliders)
    {
        Debug.Log("Overlap: " + hitCollider.name);
    }
}

### 5. Linecast بررسی اینکه آیا یک خط مستقیم بین دو نقطه با اشیاء برخورد دارد یا نه.

void Update()
{
    if (Physics.Linecast(transform.position, target.position))
    {
        Debug.Log("Linecast hit something!");
    }
}

### 6. CapsuleCast پرتاب یک کپسول از یک نقطه مشخص در یک جهت خاص و بررسی برخورد آن با اشیاء.

void Update()
{
    Ray ray = new Ray(transform.position, transform.forward);
    RaycastHit hit;
    if (Physics.CapsuleCast(transform.position, transform.position + Vector3.up, 1.0f, transform.forward, out hit, 100))
    {
        Debug.Log("Hit: " + hit.collider.name);
    }
}

### 7. CheckSphere بررسی اینکه آیا یک کره با شعاع مشخص با اشیاء برخورد دارد یا نه.

void Update()
{
    if (Physics.CheckSphere(transform.position, 5.0f))
    {
        Debug.Log("CheckSphere hit something!");
    }
}

### 8. CheckCapsule بررسی اینکه آیا یک کپسول با ابعاد مشخص با اشیاء برخورد دارد یا نه.

void Update()
{
    if (Physics.CheckCapsule(transform.position, transform.position + Vector3.up, 1.0f))
    {
        Debug.Log("CheckCapsule hit something!");
    }
}

### 9. CheckBox بررسی اینکه آیا یک جعبه با ابعاد مشخص با اشیاء برخورد دارد یا نه.

void Update()
{
    if (Physics.CheckBox(transform.position, new Vector3(1, 1, 1)))
    {
        Debug.Log("CheckBox hit something!");
    }
}

### 10. OverlapBox بازگرداندن تمام اشیایی که در داخل یک جعبه با ابعاد مشخص قرار دارند.

void Update()
{
    Collider[] hitColliders = Physics.OverlapBox(transform.position, new Vector3(1, 1, 1));
    foreach (Collider hitCollider in hitColliders)
    {
        Debug.Log("OverlapBox: " + hitCollider.name);
    }
}

### 11. OverlapCapsule بازگرداندن تمام اشیایی که در داخل یک کپسول با ابعاد مشخص قرار دارند.

void Update()
{
    Collider[] hitColliders = Physics.OverlapCapsule(transform.position, transform.position + Vector3.up, 1.0f);
    foreach (Collider hitCollider in hitColliders)
    {
        Debug.Log("OverlapCapsule: " + hitCollider.name);
    }
}

### 12. IgnoreCollision نادیده گرفتن برخورد بین دو کلایدر.

void Start()
{
    Collider collider1 = GetComponent<Collider>();
    Collider collider2 = target.GetComponent<Collider>();
    Physics.IgnoreCollision(collider1, collider2);
}

### 13. IgnoreLayerCollision نادیده گرفتن برخورد بین دو لایه.

void Start()
{
    Physics.IgnoreLayerCollision(8, 9); // نادیده گرفتن برخورد بین لایه‌های 8 و 9
}

#یونیتی #برنامه_نویسی

متد DontDestroyOnLoad به عنوان یک متد استاتیک در Unity استفاده می‌شود تا از از دست رفتن یک شیء در زمان بارگذاری صحنه جلوگیری کند. این متد معمولاً برای حفظ اجزاء مهمی که باید در تمامی صحنه‌ها حضور داشته باشند، مورد استفاده قرار می‌گیرد، مثل اجزاء UI یا منابع مرکزی. مثال: فرض کنید یک شیء به نام "GameManager" داریم که شامل اطلاعات وضعیت بازی و دسترسی به منابع مهم است. می‌خواهیم این شیء را در تمامی صحنه‌ها حفظ کنیم تا اطلاعات بازی از دست نرود. برای این منظور، می‌توانیم از متد DontDestroyOnLoad استفاده کنیم.

using UnityEngine;

public class GameManager : MonoBehaviour
{
   public  static GameManager instance;

    void Awake()
    {
        // بررسی وجود چنین شیءی
        if (instance == null)
        {
            // اگر شیء وجود نداشت، این شیء را تنظیم کنید
            instance = this;
            // این شیء را از از بین نمیرود و در تمامی صحنه‌ها حفظ می‌شود
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            // اگر شیء قبلاً تنظیم شده بود، این شیء را از بین ببرید
            Destroy(gameObject);
        }
    }

    // توابع و منطق بازی اینجا اضافه شود
}

در این مثال، وقتی که "GameManager" بارگذاری می‌شود، ما از DontDestroyOnLoad استفاده می‌کنیم تا از از دست رفتن "GameManager" در هر تغییر صحنه جلوگیری کنیم. این کار باعث می‌شود که "GameManager" در تمامی صحنه‌های بازی حضور داشته باشد و اطلاعات مهم بازی در آن حفظ شود. #یونیتی #برنامه_نویسی

در دیباگ دات لاگ (Debug.Log)، می‌توان از تگ‌های HTML برای فرمت دهی به متن استفاده کرد تا اطلاعات را بهتر سازماندهی کنیم و آنها را برجسته کنیم. در زیر تعدادی از تگ‌های HTML که می‌توانید در استفاده از دیباگ دات لاگ بهره ببرید را بررسی می‌کنیم: ### 1. <b> - Bold: این تگ متن را توسط متن‌های دیباگ دات لاگ به شکل ضخیم نمایش می‌دهد.

Debug.Log("<b>Important Message:</b> This is an important message.");

### 2. <i> - Italic: این تگ متن را توسط متن‌های دیباگ دات لاگ به شکل کج نمایش می‌دهد.

Debug.Log("<i>Notice:</i> This is a notice.");

### 3. <color> - Color: این تگ به شما امکان می‌دهد تا رنگ متن دیباگ دات لاگ را تغییر دهید.

Debug.Log("<color=red>Error:</color> This is an error message."); // نمایش با رنگ قرمز

### 4. <size> - Size: این تگ به شما امکان می‌دهد اندازه متن دیباگ دات لاگ را تغییر دهید.

Debug.Log("<size=20>Big Message:</size> This is a big message."); // اندازه فونت 20 پیکسل

### 5. <b><color> - Bold and Color: می‌توانید ترکیبی از تگ‌ها را برای نمایش متن با رنگ و ضخامت مشخص استفاده کنید.

Debug.Log("<b><color=blue>Info:</color></b> This is an informational message."); // نمایش با رنگ آبی و ضخیم

این تگ‌ها به شما امکان می‌دهند تا اطلاعات دیباگ خود را به شکلی زیبا و مفهومی تر نمایش دهید و برای برجسته کردن متن‌های مهم در خروجی دیباگ استفاده کنید. #یونیتی #برنامه_نویسی

درود دوستان این بازی اول منه قرار بود آنلاین باشه ولی خب نشد دیگه آفلاین منتشر کردم دوست داشتید نصب کنید سپاس❤️ https://myket.ir/app/com.Wold.Jasmine

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

در اینجا یک مثال از استفاده از کورتاین (Coroutine) در Unity برای انجام یک فعالیت و همچنین محاسبه درصد پیشرفت آن فعالیت آورده شده است. در این مثال، فرض می‌کنیم که یک شیء را از مکان A به مکان B حرکت دهیم و در صورتی که این حرکت زمان‌بر باشد، می‌خواهیم درصد پیشرفت آن را نشان دهیم.

using UnityEngine;
using System.Collections;

public class MoveObject : MonoBehaviour
{
    public Transform startPoint;
    public Transform endPoint;
    public float duration = 5f;

    void Start()
    {
        // شروع کورتاین برای حرکت دادن شیء
        StartCoroutine(MoveObjectCoroutine());
    }

    IEnumerator MoveObjectCoroutine()
    {
        float elapsedTime = 0f;

        while (elapsedTime < duration)
        {
            // محاسبه درصد پیشرفت حرکت
            float progress = elapsedTime / duration * 100f;
            Debug.Log("Progress: " + progress.ToString("F2") + "%");

            // حرکت دادن شیء بین دو نقطه به اندازه زمان گذشته
            transform.position = Vector3.Lerp(startPoint.position, endPoint.position, elapsedTime / duration);

            // انتظار یک فریم
            yield return null;

            // افزودن زمان گذشته به زمان کل
            elapsedTime += Time.deltaTime;
        }

        // اطمینان از قرار گرفتن شیء در مکان مقصد
        transform.position = endPoint.position;
        Debug.Log("Object has reached the destination.");
    }
}

در این مثال، یک کورتاین به نام MoveObjectCoroutine تعریف شده است. این کورتاین مسئول حرکت دادن یک شیء بین دو نقطه (startPoint و endPoint) در زمان duration می‌باشد. در هر فریم، محاسبه می‌شود که چقدر از زمان مقرر گذشته و درصد پیشرفت حرکت محاسبه می‌شود. سپس با استفاده از تابع Lerp`، شیء به اندازه زمان گذشته به طور خطی بین دو نقطه حرکت می‌کند. این فرآیند تا زمانی ادامه پیدا می‌کند که زمان گذشته از مدت زمان مشخص شده (`duration) بیشتر شود. استفاده از کورتاین‌ها در Unity برای فرایندهایی که ممکن است زمان‌بر باشند و نیاز به پیگیری پیشرفت داشته باشند بسیار مفید است. این امر به برنامه‌های شما اجازه می‌دهد تا پاسخگو باشند و در عین حال به کاربر اطلاعاتی مانند درصد پیشرفت را نمایش دهند. #یونیتی #برنامه_نویسی

در Unity، تسک‌ها (Tasks) معمولاً با استفاده از کلاس‌هایی همچون AsyncOperation`، `Coroutine و یا Task از فضای‌نام System.Threading.Tasks ایجاد می‌شوند. این تسک‌ها برای انجام عملیاتی که ممکن است زمان‌بر باشد و مانع از اجرای همروند سایر قسمت‌های برنامه نشوند، استفاده می‌شوند. یک مثال ساده از استفاده از تسک در Unity می‌تواند این باشد که فرض کنید می‌خواهید یک فایل را بخوانید و پس از خواندن آن، محتوای آن را در کنسول نمایش دهید. این کار ممکن است زمان‌بر باشد، بنابراین بهتر است آن را در یک تسک اجرا کنید تا برنامه به طور همزمان ادامه پیدا کند.

using UnityEngine;
using System.IO;
using System.Threading.Tasks;

public class FileReader : MonoBehaviour
{
    void Start()
    {
        // ایجاد یک تسک برای خواندن فایل
        Task<string> readFileTask = ReadFileAsync("example.txt");

        // ادامه اجرای برنامه بدون انتظار برای پایان تسک
        Debug.Log("Program continues to execute...");

        // منتظر ماندن تا تسک خواندن فایل به پایان برسد
        readFileTask.ContinueWith(previousTask =>
        {
            // پس از اتمام تسک خواندن فایل، نمایش محتوای آن در کنسول
            Debug.Log("File content: " + previousTask.Result);
        });
    }

    // تعریف یک تابع برای خواندن فایل به صورت همروند
    private async Task<string> ReadFileAsync(string filePath)
    {
        string fileContent = "";

        // انجام عملیات خواندن فایل در یک تسک
        await Task.Run(() =>
        {
            // کد خواندن فایل
            if (File.Exists(filePath))
            {
                fileContent = File.ReadAllText(filePath);
            }
            else
            {
                Debug.LogError("File not found: " + filePath);
            }
        });

        return fileContent;
    }
}

در این مثال، یک تسک ایجاد می‌شود تا فایلی با نام "example.txt" را بخواند. سپس برنامه ادامه اجرای خود را دارد بدون اینکه منتظر پایان خواندن فایل شود. پس از اتمام تسک خواندن فایل، محتوای فایل در کنسول نمایش داده می‌شود. کاربرد تسک‌ها در Unity معمولاً برای انجام عملیات زمان‌بر همچون خواندن/نوشتن فایل، درخواست‌های شبکه، یا انیمیشن‌های پیچیده استفاده می‌شود، تا برنامه به طور همزمان و پاسخگو باشد و از توقف ناشی از انجام عملیات‌های زمان‌بر جلوگیری شود. #یونیتی #برنامه_نویسی

الگوی استراتژی (Strategy Pattern) یک الگوی طراحی است که به شما امکان می‌دهد یک خانواده از الگوریتم‌ها را تعریف کرده و آن‌ها را قابل تعویض کنید. به این ترتیب، شما می‌توانید یک الگوریتم خاص را از بین چندین الگوریتم موجود انتخاب کرده و استفاده کنید، بدون اینکه نیازی به تغییر کد مربوط به کلاس اصلی داشته باشید. یک مثال ساده از الگوی استراتژی در Unity ممکن است برای مدیریت حرکت یک شخصیت در بازی باشد. ما می‌توانیم چندین استراتژی حرکت مختلف را تعریف کنیم و با تغییر استراتژی، حرکت شخصیت را تغییر دهیم. در اینجا یک مثال ساده از الگوی استراتژی برای مدیریت حرکت شخصیت در یک بازی Unity است:

using UnityEngine;

// رابط استراتژی
public interface IMovementStrategy 
{
    void Move();
}

// استراتژی‌های خاص
public class WalkStrategy : IMovementStrategy 
{
    public void Move() 
    {
        Debug.Log("در حال راه رفتن...");
    }
}

public class RunStrategy : IMovementStrategy 
{
    public void Move() 
    {
        Debug.Log("در حال دویدن...");
    }
}

// متناسب
public class Character 
{
    private IMovementStrategy movementStrategy;

    public void SetMovementStrategy(IMovementStrategy strategy) 
    {
        movementStrategy = strategy;
    }

    public void Move() 
    {
        movementStrategy.Move();
    }
}

در این مثال، IMovementStrategy یک رابط است که تمام استراتژی‌های مربوط به حرکت را پیاده‌سازی می‌کند. WalkStrategy و RunStrategy دو استراتژی مختلف برای حرکت شخصیت هستند. Character یک کلاس Context است که استراتژی مورد استفاده را مدیریت می‌کند و با استفاده از متد `Move`، حرکت شخصیت را اجرا می‌کند. حالا می‌توانیم این کد را به این صورت استفاده کنیم:

Character character = new Character();

// تنظیم استراتژی حرکت به راه رفتن
character.SetMovementStrategy(new WalkStrategy());
character.Move(); // Output: در حال راه رفتن...

// تغییر استراتژی به دویدن
character.SetMovementStrategy(new RunStrategy());
character.Move(); // Output: در حال دویدن...

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

الگوی سازنده (Builder Pattern) یک الگوی طراحی است که برای ایجاد یک شیء پیچیده و گرانبها با استفاده از یک سری فرایند مرحله‌ای استفاده می‌شود. این الگو اجازه می‌دهد تا یک شیء را به صورت مرحله به مرحله ایجاد کرده و در نهایت آن را با یک روش ساده به دست آورید. یک مثال شایع برای الگوی سازنده در Unity می‌تواند برای ایجاد یک شیء پیچیده مانند یک آبجکت با ویژگی‌های مختلف در یک بازی باشد. برای مثال، فرض کنید می‌خواهید یک شیء Player را ایجاد کنید که شامل ویژگی‌هایی مانند نام، سلامتی اولیه، سرعت و غیره است. در اینجا یک مثال از الگوی سازنده برای ایجاد یک کلاس Player در Unity است:

using UnityEngine;

// رابط سازنده
public interface IPlayerBuilder 
{
    void SetName(string name);
    void SetHealth(int health);
    void SetSpeed(float speed);
    Player GetPlayer();
}

// پیاده‌سازی سازنده
public class DefaultPlayerBuilder : IPlayerBuilder {
    private string playerName;
    private int playerHealth;
    private float playerSpeed;

    public void SetName(string name) 
    {
        playerName = name;
    }

    public void SetHealth(int health)
    {
        playerHealth = health;
    }

    public void SetSpeed(float speed) 
    {
        playerSpeed = speed;
    }

    public Player GetPlayer() 
    {
        return new Player(playerName, playerHealth, playerSpeed);
    }
}

// مدیر
public class PlayerCreator 
{
    private IPlayerBuilder playerBuilder;

    public PlayerCreator(IPlayerBuilder builder) 
    {
        playerBuilder = builder;
    }

    public void CreatePlayer(string name, int health, float speed) 
    {
        playerBuilder.SetName(name);
        playerBuilder.SetHealth(health);
        playerBuilder.SetSpeed(speed);
    }
}

// کلاس محصول
public class Player 
{
    public string Name { get; private set; }
    public int Health { get; private set; }
    public float Speed { get; private set; }

    public Player(string name, int health, float speed) 
    {
        Name = name;
        Health = health;
        Speed = speed;
    }

    public void DisplayInfo() 
    {
        Debug.Log($"Player Name: {Name}, Health: {Health}, Speed: {Speed}");
    }
}

در این مثال، IPlayerBuilder یک رابط برای سازنده‌های مختلف است که متدهای مختلفی را برای تنظیم ویژگی‌های Player دارد. DefaultPlayerBuilder یک پیاده‌سازی از IPlayerBuilder است که Player را به روش پیش‌فرض ایجاد می‌کند. PlayerCreator یک مدیر است که به Builder امکان ساخت Player با استفاده از متدهای مختلف را می‌دهد. Player یک کلاس Product است که شیء نهایی Player را نشان می‌دهد و ویژگی‌های آن را مدیریت می‌کند. این الگو اجازه می‌دهد تا ایجاد و تنظیم یک شیء پیچیده را از جزئیات ساخت جدا کنید، به شما امکان می‌دهد که به راحتی ویژگی‌های مختلف را تغییر دهید و همچنین کد ساخت را مجدداً استفاده کنید. #یونیتی #برنامه_نویسی

الگوی وضعیت (State Pattern) معمولاً برای مدیریت رفتارهای مختلف یک شیء در وضعیت‌های مختلف استفاده می‌شود. در مثال زیر، یک سیستم ساده‌ای برای مدیریت وضعیت یک دستگاه نور را پیاده‌سازی می‌کنیم. در اینجا، یک کلاس برای نمایش دستگاه نور داریم که در وضعیت‌های مختلف قرار می‌گیرد:

using UnityEngine;

// کلاس انتزاعی برای وضعیت‌های مختلف دستگاه نور
public abstract class LightState
{
    public abstract void HandlePower(LightSwitch lightSwitch);
}

// وضعیت روشن
public class OnState : LightState
{
    public override void HandlePower(LightSwitch lightSwitch)
    {
        Debug.Log("Light is already on.");
    }
}

// وضعیت خاموش
public class OffState : LightState
{
    public override void HandlePower(LightSwitch lightSwitch)
    {
        Debug.Log("Light is now on.");
        lightSwitch.SetState(new OnState());
    }
}

// کلاس دستگاه نور
public class LightSwitch : MonoBehaviour
{
    private LightState currentState;

    public LightSwitch()
    {
        currentState = new OffState();
    }

    // متد برای تغییر وضعیت دستگاه نور به روشن
    public void TurnOn()
    {
        currentState.HandlePower(this);
    }

    // متد برای تغییر وضعیت دستگاه نور به خاموش
    public void TurnOff()
    {
        currentState.HandlePower(this);
    }

    // متد برای تنظیم وضعیت فعلی دستگاه نور
    public void SetState(LightState state)
    {
        currentState = state;
    }
}

حالا می‌توانیم از این کلاس‌ها برای مدیریت وضعیت دستگاه نور استفاده کنیم:

using UnityEngine;

public class GameManager : MonoBehaviour
{
    private void Start()
    {
        LightSwitch lightSwitch = new LightSwitch();

        // روشن کردن دستگاه نور (وضعیت اولیه خاموش)
        lightSwitch.TurnOn();

        // دوباره روشن کردن دستگاه نور (وضعیت اولیه روشن)
        lightSwitch.TurnOn();

        // خاموش کردن دستگاه نور (از وضعیت روشن به خاموش)
        lightSwitch.TurnOff();

        // دوباره خاموش کردن دستگاه نور (وضعیت اولیه خاموش)
        lightSwitch.TurnOff();
    }
}

در این مثال، هر وضعیت (روشن یا خاموش) به عنوان یک کلاس انتزاعی پیاده‌سازی شده است و ما از کلاس LightSwitch برای مدیریت وضعیت دستگاه نور استفاده می‌کنیم. با تغییر وضعیت دستگاه نور، عملکرد آن نیز تغییر می‌کند. این نشان می‌دهد که الگوی وضعیت چگونه می‌تواند به مدیریت رفتارهای مختلف یک شیء در وضعیت‌های مختلف کمک کند. #یونیتی #برنامه_نویسی

الگوی کارخانه (Factory Pattern) در Unity معمولاً برای ایجاد شیء‌های مختلف با استفاده از یک روش مشترک استفاده می‌شود. در مثال زیر، یک سیستم ایجاد شیء برای ایجاد دشمنان در یک بازی را پیاده‌سازی می‌کنیم. در اینجا، یک کلاس انتزاعی برای دشمن‌ها داریم:

using UnityEngine;

// کلاس انتزاعی برای دشمن‌ها
public abstract class Enemy : MonoBehaviour
{
    public abstract void Attack();
    public abstract void Move();
}

سپس، دو کلاس مختلف برای دشمنان ایجاد می‌کنیم که از کلاس انتزاعی Enemy ارث‌بری می‌کنند:

using UnityEngine;

// کلاسی برای دشمن نوع A
public class EnemyTypeA : Enemy
{
    public override void Attack()
    {
        Debug.Log("Enemy Type A attacks!");
    }

    public override void Move()
    {
        Debug.Log("Enemy Type A moves!");
    }
}

// کلاسی برای دشمن نوع B
public class EnemyTypeB : Enemy
{
    public override void Attack()
    {
        Debug.Log("Enemy Type B attacks!");
    }

    public override void Move()
    {
        Debug.Log("Enemy Type B moves!");
    }
}

سپس، یک کلاس کارخانه ایجاد می‌کنیم که به عنوان کارخانه‌ای برای ایجاد شیء‌های مختلف دشمن استفاده می‌شود:

using UnityEngine;

// کلاس کارخانه برای ایجاد دشمنان
public class EnemyFactory : MonoBehaviour
{
    // متد ایجاد دشمن با توجه به نوع
    public Enemy CreateEnemy(string enemyType)
    {
        switch (enemyType)
        {
            case "TypeA":
                return new EnemyTypeA();
            case "TypeB":
                return new EnemyTypeB();
            default:
                Debug.LogError("Unknown enemy type: " + enemyType);
                return null;
        }
    }
}

حالا می‌توانیم از کلاس کارخانه برای ایجاد دشمنان با نوع‌های مختلف استفاده کنیم:

using UnityEngine;

public class GameManager : MonoBehaviour
{
    private EnemyFactory enemyFactory;

    private void Start()
    {
        enemyFactory = GetComponent<EnemyFactory>();

        // ایجاد دشمن نوع A
        Enemy enemyA = enemyFactory.CreateEnemy("TypeA");
        enemyA.Attack();
        enemyA.Move();

        // ایجاد دشمن نوع B
        Enemy enemyB = enemyFactory.CreateEnemy("TypeB");
        enemyB.Attack();
        enemyB.Move();
    }
}

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

الگوی مشاهده‌گر (Observer Pattern) معمولاً برای پیاده‌سازی رویدادها و واکنش به تغییرات در یک سیستم استفاده می‌شود. در مثال زیر، یک سیستم ساده پیام‌رسان را پیاده‌سازی می‌کنیم که اجازه می‌دهد که کاربران به عنوان مشترکین پیام‌های دیگر کاربران را دریافت کنند. در اینجا، یک کلاس برای مشترکین (یا Observer) و یک کلاس برای موضوع یا مشاهده‌گر (یا Subject) ایجاد می‌کنیم:

using System.Collections.Generic;
using UnityEngine;


// Interface برای مشترکین
public interface IObserver
{
    void Update(string message);
}

// کلاس برای مشترکین
public class User : IObserver
{
    private string name;

    public User(string name)
    {
        this.name = name;
    }

    // متد برای به‌روزرسانی پیام
    public void Update(string message)
    {
        Debug.Log(name + " received message: " + message);
    }
}

// کلاس برای موضوع یا مشاهده‌گر
public class Messenger
{
    // لیستی برای نگهداری مشترکین
    private List<IObserver> observers = new List<IObserver>();

    // متد برای اضافه کردن مشترک
    public void AddObserver(IObserver observer)
    {
        observers.Add(observer);
    }

    // متد برای حذف مشترک
    public void RemoveObserver(IObserver observer)
    {
        observers.Remove(observer);
    }

    // متد برای ارسال پیام به تمام مشترکین
    public void SendMessage(string message)
    {
        foreach (var observer in observers)
        {
            observer.Update(message);
        }
    }
}

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

using UnityEngine;

public class MessageSystem : MonoBehaviour
{
    private Messenger messenger = new Messenger();

    private void Start()
    {
        // اضافه کردن مشترکین
        messenger.AddObserver(new User("User1"));
        messenger.AddObserver(new User("User2"));
        messenger.AddObserver(new User("User3"));

        // ارسال پیام به تمام مشترکین
        messenger.SendMessage("Hello, everyone!");
    }
}

در این مثال، هر زمان که پیامی ارسال شود، تمام مشترکین از طریق متد Update در کلاس User به روزرسانی می‌شوند و پیام را دریافت می‌کنند. این نشان دهنده عملکرد الگوی مشاهده‌گر است که مشترکین به موضوع مشاهده‌گر مشترک شده و به‌روزرسانی‌های مربوطه را دریافت می‌کنند. #یونیتی #برنامه_نویسی

یک مثال ساده را با الگوی تک نمونه (Singleton) در Unity ببینیم. فرض کنید که می‌خواهیم یک مدیر موسیقی را پیاده‌سازی کنیم که به ما اجازه پخش موسیقی را بدهد. برای این کار، از الگوی تک نمونه استفاده می‌کنیم تا فقط یک نمونه از مدیر موسیقی در طول عمر برنامه وجود داشته باشد و از آن برای پخش موسیقی استفاده کنیم. در اینجا، یک کلاس Singleton برای مدیر موسیقی خواهیم داشت:

using UnityEngine;

public class AudioManager : MonoBehaviour
{
    // این متغیر به عنوان نمونه یکتا از کلاس استفاده می‌شود
    public static AudioManager Instance;

    // این متغیر مسئول پخش موسیقی است
    AudioSource audioSource;

    
    // متد اولیه‌سازی کلاس
    void Awake()
    {

        instance = this;

        // دریافت AudioSource برای پخش موسیقی
        audioSource = gameObject.GetComponent<AudioSource>();
    }

    // متد پخش موسیقی
    public void PlayMusic(AudioClip music)
    {
        audioSource.clip = music;
        audioSource.Play();
    }
}

سپس می‌توانیم از این کلاس در دیگر اشیاء و اسکریپت‌ها برای پخش موسیقی استفاده کنیم:

using UnityEngine;

public class MusicPlayer : MonoBehaviour
{
    // موسیقی‌های مختلف
    public AudioClip backgroundMusic;
    public AudioClip victoryMusic;

    // متد اجرا شده هنگامی که اشیاء فعال می‌شوند
    void Start()
    {
        // پخش موسیقی پس زمینه در هنگام شروع بازی
        AudioManager.Instance.PlayMusic(backgroundMusic);
    }

    // متد اجرا شده هنگامی که شرایط مشخصی برآورده می‌شود
    public void PlayVictoryMusic()
    {
        // پخش موسیقی پیروزی
        AudioManager.Instance.PlayMusic(victoryMusic);
    }
}

در این مثال، با استفاده از الگوی تک نمونه، اطمینان حاصل می‌شود که همیشه یک نمونه از کلاس AudioManager وجود دارد و می‌توانیم به آن از هر قسمتی در بازی دسترسی داشته باشیم. #یونیتی #برنامه_نویسی

درود دوستان عزیز، امیدوارم حالتون عالی باشه. به درخواست یکی از دوستان عزیز، قصد دارم توضیحاتی در مورد الگوهای طراحی مهم در یونیتی ارائه بدم و به تدریج مثال‌هایی رو هم ارائه بدم. پس اگر می‌خواهید در پروژه‌های بزرگتر با مشکل مواجه نشوید، این پست‌ها را با دقت مطالعه کنید. دیزاین پترن‌ها در Unity به عنوان الگوهای معماری برنامه‌نویسی استفاده می‌شوند که به توسعه‌دهندگان کمک می‌کنند تا کد بهتری بنویسند و ساختار بهتری برای پروژه‌های خود ایجاد کنند. در زیر به برخی از اصطلاحات و دیزاین پترن‌های معروف در Unity اشاره میشود: 1. Singleton Pattern (الگوی تک نمونه): این الگو به توسعه‌دهندگان کمک می‌کند تا یک نمونه از یک کلاس را فقط یک بار ایجاد کنند و سپس از این نمونه به عنوان نقطه دسترسی به آن کلاس استفاده کنند. این الگو معمولاً برای مواردی مانند مدیریت داده‌های عمومی (مانند مدیر صدا یا مدیر اسکریپت) استفاده می‌شود. 2. Observer Pattern (الگوی مشاهده‌گر): این الگو به توسعه‌دهندگان این امکان را می‌دهد که یک مکانیزم اعلانیه (معمولاً یک رویداد) برای اشتراک اطلاعات بین اشیا ایجاد کنند. معمولاً این الگو برای پاسخ به رویدادها و واکنش به تغییرات در بازی استفاده می‌شود. 3. Factory Pattern (الگوی کارخانه): این الگو به توسعه‌دهندگان این امکان را می‌دهد که ایجاد شیء را از پیاده‌سازی جداگانه‌ای که برای ساختن شیء مورد نظر مسئول است، جدا کنند. این الگو برای ایجاد نمونه‌های مختلف اشیاء بر اساس پارامترهای ورودی مورد استفاده قرار می‌گیرد. 4. State Pattern (الگوی وضعیت): این الگو به توسعه‌دهندگان کمک می‌کند تا رفتارهای مختلف یک شیء را در وضعیت‌های مختلف تعریف کنند. به این ترتیب، هرگاه وضعیت یک شیء تغییر کند، رفتار آن نیز تغییر می‌کند. اینها تنها چند نمونه از دیزاین پترن‌هایی هستند که می‌توانید در Unity استفاده کنید. بسته به نیازهای پروژه خود، ممکن است به دیگر الگوها و رویکردهای معماری هم پی ببرید. #یونیتی #برنامه_نویسی