الگوی وضعیت (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 برای مدیریت وضعیت دستگاه نور استفاده می‌کنیم. با تغییر وضعیت دستگاه نور، عملکرد آن نیز تغییر می‌کند. این نشان می‌دهد که الگوی وضعیت چگونه می‌تواند به مدیریت رفتارهای مختلف یک شیء در وضعیت‌های مختلف کمک کند.

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

الگوی سازنده (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 را نشان می‌دهد و ویژگی‌های آن را مدیریت می‌کند.

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

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

الگوی استراتژی (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. این نشان می‌دهد که الگوی استراتژی چگونه از تغییرات محلی جلوگیری می‌کند و انعطاف‌پذیری در برنامه را افزایش می‌دهد.

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

در 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 معمولاً برای انجام عملیات زمان‌بر همچون خواندن/نوشتن فایل، درخواست‌های شبکه، یا انیمیشن‌های پیچیده استفاده می‌شود، تا برنامه به طور همزمان و پاسخگو باشد و از توقف ناشی از انجام عملیات‌های زمان‌بر جلوگیری شود.

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

در اینجا یک مثال از استفاده از کورتاین (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 برای فرایندهایی که ممکن است زمان‌بر باشند و نیاز به پیگیری پیشرفت داشته باشند بسیار مفید است. این امر به برنامه‌های شما اجازه می‌دهد تا پاسخگو باشند و در عین حال به کاربر اطلاعاتی مانند درصد پیشرفت را نمایش دهند.

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

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

🎨 فرمت‌دهی متن در Debug.Log یونیتی با HTML

در Debug.Log یونیتی می‌توان از تگ‌های HTML برای فرمت‌دهی به متن استفاده کرد تا اطلاعات بهتر سازماندهی و برجسته شوند. در ادامه، چند نمونه پرکاربرد را می‌بینید:


🔹 ضخیم‌کردن متن — `<b>`
نمایش متن با ضخامت بیشتر در خروجی:

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

🔹 کج‌کردن متن — `<i>`
نمایش متن به حالت ایتالیک (کج):

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

🔹 تغییر رنگ — `<color>`
نمایش متن با رنگ دلخواه:

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

🔹 تغییر اندازه — `<size>`
تنظیم اندازه فونت متن:

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

🔹 ترکیبی — `<b><color>`
نمایش متن با ضخامت و رنگ همزمان:

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

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

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

متد 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" در تمامی صحنه‌های بازی حضور داشته باشد و اطلاعات مهم بازی در آن حفظ شود.

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

متدهای کلاس 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
}

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

یونیتی ایونت‌ها (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!");
        }
    }
}

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

### نتیجه‌گیری

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

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

دوستان عزیز 🌟

من مدت زیادی هست که با عشق و علاقه در کانال Start Unity فعالیت می‌کنم و آموزش‌های متنی و کدهای یونیتی رو با شما به اشتراک می‌گذارم. از حمایت‌های شما بسیار ممنونم.

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

همچنین می‌خواهم از دوست عزیزم که کانال رو بوست کرد، تشکر ویژه کنم. حمایت تو برای من بسیار ارزشمنده ❤️

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

از همراهی و حمایت‌های شما بسیار سپاسگزارم. با هم می‌تونیم این کانال رو به یکی از بهترین منابع آموزشی یونیتی تبدیل کنیم 🚀

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

درود به همه! 🌟

در این سری آموزش‌ها، قصد داریم به بررسی و یادگیری ویرایشگرهای سفارشی (Custom Editors) در یونیتی بپردازیم. ویرایشگرهای سفارشی ابزارهای قدرتمند و کاربردی هستند که می‌توانند به شما کمک کنند تا محیط ویرایشگر یونیتی را متناسب با نیازهای خاص پروژه‌های خود تغییر دهید و تجربه بهتری از کار با آن داشته باشید.

کاربرد و مزایای ویرایشگرهای سفارشی

ویرایشگرهای سفارشی به شما این امکان را می‌دهند که:

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

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

3. افزایش بهره‌وری: ویرایشگرهای سفارشی می‌توانند به شما کمک کنند تا فرآیندهای تکراری و زمان‌بر را به سرعت و به صورت مؤثرتر انجام دهید. به عنوان مثال، می‌توانید با اضافه کردن دکمه‌های خاصی، تغییرات زیادی را به صورت یکجا اعمال کنید.

4. پروژه‌های حرفه‌ای‌تر: با تسلط بر ویرایشگرهای سفارشی، می‌توانید پروژه‌های حرفه‌ای‌تری را ایجاد کنید که به صورت بهینه و منظم‌تری با ویژگی‌های مورد نظر شما سازگار هستند.

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

امیدوارم این آموزش‌ها برای شما مفید و کاربردی باشند و بتوانید از این تکنیک‌ها در پروژه‌های خود بهره‌برداری کنید! 🎮

---
💬 اگر سوالی دارید یا نیاز به راهنمایی بیشتر است، حتما در نظرات با ما در میان بگذارید.
🔔 برای دریافت آموزش‌های بیشتر، کانال ما را دنبال کنید.

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

آموزش ایجاد Custom Editor در یونیتی

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

مرحله 1: ایجاد اسکریپت PlayerStats

ابتدا باید یک اسکریپت ساده ایجاد کنیم که شامل چندین متغیر برای وضعیت‌های مختلف بازیکن باشد. به این اسکریپت PlayerStats می‌گوییم:

using UnityEngine;

public class PlayerStats : MonoBehaviour
{
    public int health = 100;
    public int mana = 50;
    public int stamina = 75;
}

این اسکریپت سه متغیر health`، `mana و stamina را تعریف می‌کند که می‌خواهیم آنها را در ویرایشگر سفارشی نمایش دهیم.

مرحله 2: ایجاد اسکریپت PlayerStatsEditor

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

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(PlayerStats))]
public class PlayerStatsEditor : Editor
{
    public override void OnInspectorGUI()
    {
        // بازیابی مرجع اسکریپت PlayerStats
        PlayerStats playerStats = (PlayerStats)target;

        // نمایش برچسب
        EditorGUILayout.LabelField("Player Stats", EditorStyles.boldLabel);

        // نمایش اسلایدرها برای تنظیم مقادیر
        playerStats.health = EditorGUILayout.IntSlider("Health", playerStats.health, 0, 100);
        playerStats.mana = EditorGUILayout.IntSlider("Mana", playerStats.mana, 0, 100);
        playerStats.stamina = EditorGUILayout.IntSlider("Stamina", playerStats.stamina, 0, 100);

        // اگر تغییری ایجاد شد، اسکریپت را علامت‌گذاری کنید
        if (GUI.changed)
        {
            EditorUtility.SetDirty(playerStats);
        }
    }
}

توضیحات کد

- توضیح [CustomEditor(typeof(PlayerStats))]: این attribute به یونیتی می‌گوید که این کلاس ویرایشگر سفارشی برای PlayerStats است.

- توضیح Editor: کلاس پایه‌ای است که برای ایجاد ویرایشگرهای سفارشی استفاده می‌شود.

- توضیح OnInspectorGUI: این متد برای رسم رابط کاربری ویرایشگر سفارشی استفاده می‌شود. در اینجا متد OnInspectorGUI اورراید شده تا رفتار دلخواه پیاده‌سازی شود.

- توضیح EditorGUILayout.LabelField: این متد برای نمایش یک برچسب با استایل خاص استفاده می‌شود.

- توضیح EditorGUILayout.IntSlider: این متد برای ایجاد اسلایدرهایی که به شما امکان تغییر مقدار متغیرها را می‌دهد، استفاده می‌شود.

- توضیح GUI.changed و EditorUtility.SetDirty: این‌ها برای اطمینان از ذخیره تغییرات در ویرایشگر استفاده می‌شوند.

امیدوارم این آموزش به شما کمک کند تا ویرایشگرهای سفارشی خود را بسازید و تجربه بهتری از کار با یونیتی داشته باشید! 🎮

---
💬 اگر سوالی دارید یا نیاز به راهنمایی بیشتر است، حتما در نظرات با ما در میان بگذارید.
🔔 برای دریافت آموزش‌های بیشتر، کانال ما را دنبال کنید.

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

آموزش ایجاد Custom Editor در یونیتی - قسمت دوم

درود به همه! 🌟

در قسمت قبلی، یاد گرفتیم که چگونه یک ویرایشگر سفارشی برای اسکریپت PlayerStats ایجاد کنیم. در این قسمت، قصد داریم چند ویژگی جدید به ویرایشگر سفارشی خود اضافه کنیم تا کاربردی‌تر شود.

اضافه کردن دکمه‌های سفارشی

برای اینکه بتوانیم در ویرایشگر خود عملیات خاصی را انجام دهیم، می‌توانیم دکمه‌هایی اضافه کنیم. به عنوان مثال، فرض کنید می‌خواهیم دکمه‌ای داشته باشیم که با فشار دادن آن، مقادیر health`، `mana و stamina به مقادیر پیش‌فرض برگردد.

ابتدا باید اسکریپت PlayerStats را به‌روز کنیم تا یک متد برای بازنشانی مقادیر داشته باشد:

using UnityEngine;

public class PlayerStats : MonoBehaviour
{
    public int health = 100;
    public int mana = 50;
    public int stamina = 75;

    // متد برای بازنشانی مقادیر به پیش‌فرض
    public void ResetStats()
    {
        health = 100;
        mana = 50;
        stamina = 75;
    }
}

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

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(PlayerStats))]
public class PlayerStatsEditor : Editor
{
    public override void OnInspectorGUI()
    {
        // بازیابی مرجع اسکریپت PlayerStats
        PlayerStats playerStats = (PlayerStats)target;

        // نمایش برچسب
        EditorGUILayout.LabelField("Player Stats", EditorStyles.boldLabel);

        // نمایش اسلایدرها برای تنظیم مقادیر
        playerStats.health = EditorGUILayout.IntSlider("Health", playerStats.health, 0, 100);
        playerStats.mana = EditorGUILayout.IntSlider("Mana", playerStats.mana, 0, 100);
        playerStats.stamina = EditorGUILayout.IntSlider("Stamina", playerStats.stamina, 0, 100);

        // دکمه برای بازنشانی مقادیر
        if (GUILayout.Button("Reset Stats"))
        {
            playerStats.ResetStats();
        }

        // اگر تغییری ایجاد شد، اسکریپت را علامت‌گذاری کنید
        if (GUI.changed)
        {
            EditorUtility.SetDirty(playerStats);
        }
    }
}

توضیحات کد

- توضیح ResetStats: این متد در اسکریپت PlayerStats برای بازنشانی مقادیر به مقادیر پیش‌فرض استفاده می‌شود.

- توضیح GUILayout.Button: این متد یک دکمه در ویرایشگر ایجاد می‌کند که با فشار دادن آن، متد ResetStats فراخوانی می‌شود.

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

امیدوارم این آموزش به شما کمک کند تا ویرایشگرهای سفارشی خود را بهبود بخشید و حرفه‌ای‌تر کار کنید! 🎮

---
💬 اگر سوالی دارید یا نیاز به راهنمایی بیشتر است، حتما در نظرات با ما در میان بگذارید.
🔔 برای دریافت آموزش‌های بیشتر، کانال ما را دنبال کنید.

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

آموزش ایجاد Custom Editor در یونیتی - قسمت سوم

درود به همه! 🌟

در این پست می‌خواهیم با GUIStyle در یونیتی آشنا شویم. GUIStyle یک ابزار بسیار قدرتمند است که به شما امکان می‌دهد ظاهر و رفتار عناصر گرافیکی را در ویرایشگرهای سفارشی به طور کامل تغییر دهید.

استفاده از GUIStyle برای سفارشی‌سازی متن

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

در این مثال، ما یک GUIStyle ایجاد می‌کنیم که رنگ متن، اندازه فونت، استایل فونت، و تراز متن را تغییر می‌دهد:

using UnityEngine;
using UnityEditor;

[CustomEditor(typeof(PlayerStats))]
public class PlayerStatsEditor : Editor
{
    public override void OnInspectorGUI()
    {
        // بازیابی مرجع اسکریپت PlayerStats
        PlayerStats playerStats = (PlayerStats)target;

        // ایجاد یک GUIStyle جدید
        GUIStyle myStyle = new GUIStyle();
        myStyle.fontSize = 18;
        myStyle.normal.textColor = Color.cyan;
        myStyle.fontStyle = FontStyle.Bold;
        myStyle.alignment = TextAnchor.MiddleCenter;

        // نمایش یک متن با استفاده از GUIStyle
        GUILayout.Label("Player Stats", myStyle);

        // نمایش اسلایدرها برای تنظیم مقادیر
        playerStats.health = EditorGUILayout.IntSlider("Health", playerStats.health, 0, 100);
        playerStats.mana = EditorGUILayout.IntSlider("Mana", playerStats.mana, 0, 100);
        playerStats.stamina = EditorGUILayout.IntSlider("Stamina", playerStats.stamina, 0, 100);

        // اگر تغییری ایجاد شد، اسکریپت را علامت‌گذاری کنید
        if (GUI.changed)
        {
            EditorUtility.SetDirty(playerStats);
        }
    }
}

توضیحات کد

- توضیح fontSize: اندازه فونت را تعیین می‌کند.
- توضیح normal.textColor: رنگ متن را تنظیم می‌کند.
- توضیح fontStyle: استایل فونت را به صورت Bold (پررنگ) تنظیم می‌کند.
- توضیح alignment: متن را در مرکز (وسط) تراز می‌کند.

- توضیح GUILayout.Label: این متد، متنی را با استفاده از GUIStyle تعریف‌شده نمایش می‌دهد. در اینجا، متن "Player Stats" با رنگ آبی روشن، اندازه بزرگ و استایل Bold در مرکز صفحه نمایش داده می‌شود.

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

امیدوارم این آموزش به شما کمک کند تا ویرایشگرهای سفارشی خود را با استفاده از GUIStyle بهبود ببخشید و ظاهر پروژه‌های یونیتی خود را حرفه‌ای‌تر کنید! 🎨🎮

---
💬 اگر سوالی دارید یا نیاز به راهنمایی بیشتر است، حتماً در نظرات با ما در میان بگذارید.
🔔 برای دریافت آموزش‌های بیشتر، کانال ما را دنبال کنید.

#یونیتی #ویرایشگر_سفارشی #برنامه_نویسی #GUIStyle #سفارشی‌سازی