🚀 آموزش گیت از مقدماتی تا پیشرفته

توضیح:
در این دوره گیت، از مباحث ابتدایی تا مفاهیم پیشرفته و کاربردهای عملی آن پوشش داده شده است. شما با استفاده از لینک زیر می‌توانید به تمامی ویدئوها دسترسی پیدا کنید:

🔗لینک دوره گیت

مباحثی که در دوره آموزش داده می‌شوند:
1. مقدمه‌ای به سیستم کنترل نسخه و نیازمندی‌های گیت📚
2. ایجاد یک مخزن (Repository) جدید🏗
3. اضافه کردن فایل‌ها و تغییرات به مخزن📝
4. استفاده از شاخه‌ها (Branches) و ادغام (Merge)🌲
5. حل خطاها و کنترل وضعیت (Status) فایل‌ها🛠
6. مدیریت کننده‌ها و همکاران (Collaborators) 👥
7. استفاده از گیت‌هاب (GitHub) برای همکاری و اشتراک‌گذاری پروژه🤝

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

در Unity، کلاس Time از فضای نام UnityEngine استفاده می‌شود و اطلاعات مربوط به زمان اجرای بازی را فراهم می‌کند. این کلاس شامل متدها و خصوصیاتی است که به توسعه‌دهندگان این امکان را می‌دهد تا زمان اجرای بازی را بسنجند و کنترل کنند. در زیر، تعدادی از متدها و خصوصیات مهم این کلاس توضیح داده شده‌اند:

### 1. Time.deltaTime:
- توضیح: یک خاصیت (property) که زمانی که طول یک چرخه اجرای بازی (frame) به ثانیه می‌شود را نشان می‌دهد. این مقدار معمولاً برای حرکت صاف و تطبیقی بر اساس فریم‌ها استفاده می‌شود.
- نمونه کد:

     void Update()
     {
         float movementSpeed = 5.0f;
         transform.Translate(Vector3.forward * movementSpeed * Time.deltaTime);
     }
     

### 2. Time.fixedDeltaTime:
- توضیح: یک خاصیت (property) که زمان مشخص شده برای هر چرخه اجرای بازی در حالت فیکس (Fixed Update) را نشان می‌دهد.
- نمونه کد:

     void FixedUpdate()
     {
         float rotationSpeed = 90.0f;
         transform.Rotate(Vector3.up * rotationSpeed * Time.fixedDeltaTime);
     }
     

### 3. Time.timeScale:
- توضیح: یک خاصیت (property) که مقیاس زمانی را کنترل می‌کند. مقدار 1 برابر با زمان واقعی است و مقادیر کمتر از 1 (مانند 0.5) باعث کندتر شدن بازی و مقادیر بیشتر از 1 باعث سریعتر شدن بازی می‌شوند.
- نمونه کد:

     void PauseGame()
     {
         Time.timeScale = 0.0f; // بازی را متوقف کن
     }

     void ResumeGame()
     {
         Time.timeScale = 1.0f; // ادامه اجرای بازی
     }
     

### 4. Time.time:
- توضیح: یک خاصیت (property) که میزان زمان گذشته از زمان شروع بازی را نشان می‌دهد.
- نمونه کد:

     void Update()
     {
         float elapsedTime = Time.time; // زمان گذشته از شروع بازی
         Debug.Log("Elapsed Time: " + elapsedTime);
     }
     

### 5. Time.unscaledTime:
- توضیح: یک خاصیت (property) که میزان زمان گذشته از زمان شروع بازی را نشان می‌دهد، بدون در نظر گرفتن مقیاس زمانی (Time.timeScale).
- نمونه کد:

     void Update()
     {
         float unscaledTime = Time.unscaledTime; // زمان گذشته بدون در نظر گرفتن مقیاس زمانی
         Debug.Log("Elapsed Time (Unscaled): " + unscaledTime);
     }
     

### 6. Time.fixedTime:
- توضیح: یک خاصیت (property) که میزان زمان گذشته از زمان شروع بازی را در چرخه‌های اجرای بازی محدود به حالت Fixed Update نشان می‌دهد.
- نمونه کد:

     void FixedUpdate()
     {
         float fixedTime = Time.fixedTime; // زمان گذشته از شروع بازی در حالت Fixed Update
         Debug.Log("Fixed Time: " + fixedTime);
     }
     

### 7. Time.realtimeSinceStartup:
- توضیح: یک خاصیت (property) که میزان زمان گذشته از زمان شروع سیستم (از زمان روشن بودن سیستم) را نشان می‌دهد.
- نمونه کد:

     void Start()
     {
         float realTime = Time.realtimeSinceStartup; // زمان گذشته از شروع سیستم
         Debug.Log("Real Time Since Startup: " + realTime);
     }
     

### توجه:
- این متدها و خصوصیات بیشتر در متدهای Update و FixedUpdate از MonoBehaviour به کار می‌روند.
- Time.deltaTime و Time.fixedDeltaTime معمولاً برای جلوگیری از نوسانات حرکت و اجسام در بازی در هر نرخ فریم استفاده می‌شوند.
- Time.timeScale معمولا

ً برای ایجاد اثرات مثل ایستادن زمان یا افزایش سرعت بازی استفاده می‌شود.

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

در Unity، کلاس SceneManager جهت مدیریت صحنه‌ها (scenes) استفاده می‌شود.
### 1. SceneManager.LoadScene(string sceneName):
- توضیح: این متد برای بارگذاری یک صحنه جدید با نام مشخص شده استفاده می‌شود.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // بارگذاری یک صحنه با نام "Level2"
     SceneManager.LoadScene("Level2");
     

### 2. SceneManager.LoadScene(int sceneBuildIndex):
- توضیح: این متد برای بارگذاری یک صحنه بر اساس ایندکس ساختار صحنه‌ها استفاده می‌شود. این ایندکس به ترتیب درخت صحنه‌ها در پروژه Unity است.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // بارگذاری صحنه با ایندکس 1
     SceneManager.LoadScene(1);
     

### 3. SceneManager.LoadSceneAsync(string sceneName):
- توضیح: این متد به صورت ناهمزمان (asynchronously) یک صحنه جدید را بارگذاری می‌کند، که به منظور جلوگیری از توقف اجرای بازی در حین بارگذاری صحنه استفاده می‌شود.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // بارگذاری یک صحنه به صورت ناهمزمان
     StartCoroutine(LoadSceneAsync("Level2"));
     
     IEnumerator LoadSceneAsync(string sceneName)
     {
         AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(sceneName);

         while (!asyncLoad.isDone)
         {
             float progress = Mathf.Clamp01(asyncLoad.progress / 0.9f);
             Debug.Log("Loading progress: " + progress * 100f + "%");
             yield return null;
         }
     }
     

### 4. SceneManager.LoadSceneAsync(int sceneBuildIndex):
- توضیح: همانند متد قبلی، اما با استفاده از ایندکس صحنه برای بارگذاری.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // بارگذاری صحنه به صورت ناهمزمان با استفاده از ایندکس 1
     StartCoroutine(LoadSceneAsync(1));
     

### 5. SceneManager.GetActiveScene():
- توضیح: این متد صحنه‌ای که در حال حاضر فعال است را بازمی‌گرداند.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // دریافت صحنه‌ای که در حال حاضر فعال است
     Scene currentScene = SceneManager.GetActiveScene();
     Debug.Log("Active Scene name: " + currentScene.name);
     

### 6. SceneManager.GetSceneByName(string sceneName):
- توضیح: این متد اطلاعات یک صحنه را بر اساس نام آن بازمی‌گرداند، اما بدون بارگذاری آن.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // دریافت اطلاعات یک صحنه بر اساس نام
     Scene targetScene = SceneManager.GetSceneByName("Level2");
     

### 7. SceneManager.GetSceneByBuildIndex(int buildIndex):
- توضیح: این متد اطلاعات یک صحنه را بر اساس ایندکس ساختار صحنه‌ها بازمی‌گرداند، اما بدون بارگذاری آن.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // دریافت اطلاعات یک صحنه بر اساس ایندکس
     Scene targetScene = SceneManager.GetSceneByBuildIndex(1);
     

### 8. SceneManager.LoadScene(string sceneName, LoadSceneMode mode):
- توضیح: این متد برای بارگذاری یک صحنه با حالت خاص (مثل اضافه کردن به صحنه فعلی یا جایگزین کردن آن) استفاده می‌شود.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // بارگذاری یک صحنه و جایگزین کردن صحنه فعلی
     SceneManager.LoadScene("Level2", LoadSceneMode.Single);
     

### 9. SceneManager.MergeScenes(Scene sourceScene, Scene destinationScene):
- توضیح: این متد به ترکیب (ادغام) دو صحنه بازی کمک می‌کند.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // ادغام دو صحنه
     Scene sourceScene = SceneManager.GetSceneByName("SourceScene");
     Scene destinationScene = SceneManager.GetSceneByName("DestinationScene");
     SceneManager

.MergeScenes(sourceScene, destinationScene);
     

### 10. SceneManager.UnloadScene(string sceneName):
- توضیح: این متد برای خارج کردن یک صحنه از حافظه (آن‌را آزاد کردن) استفاده می‌شود.
- نمونه کد:

     using UnityEngine.SceneManagement;

     // خارج کردن یک صحنه از حافظه
     SceneManager.UnloadScene("Level1");
     

### توجه:
- برخی از متدها و مدیریت‌ها بر اساس اطلاعات ناهمزمان (Async) عمل می‌کنند و برای اجتناب از توقف اجرای بازی در حین عملیات مهم است.

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

در یونیتی Event Methods یا متدهای رویدادها مربوط به چرخه حیات اجزای MonoBehaviour هستند. این متدها در طول زندگی یک اجزا (مثل یک شیء در بازی) فراخوانی می‌شوند. برخی از متدهای رویدادها مهم شامل Awake`، `Start`، `Update`، `FixedUpdate`، `LateUpdate و OnDestroy هستند.

### 1. Awake:
- توضیح: این متد فراخوانی می‌شود هنگامی که اجزا (مثل یک شیء) ایجاد می‌شوند. این متد معمولاً برای اولیه‌سازی منابع و اطلاعات مورد نیاز قبل از شروع بازی استفاده می‌شود.
- نمونه کد:

  void Awake()
  {
      // اولیه‌سازی منابع و اطلاعات
  }
  

### 2. Start:
- توضیح: این متد فراخوانی می‌شود در هنگام شروع اجرای بازی و پس از اجرای متد Awake. این متد برای اجرای کدهایی که به منابع دیگری (مثل اجزا دیگر یا دستورهای شروعی) وابسته هستند، مفید است.
- نمونه کد:

  void Start()
  {
      // کدهای شروعی پس از اجرای Awake
  }
  

### 3. Update:
- توضیح: این متد در هر چرخه فریم (frame) فراخوانی می‌شود. این متد برای اعمال تغییرات مربوط به لحظه به لحظه (مثل حرکت شیء) استفاده می‌شود.
- نمونه کد:

  void Update()
  {
      // کدهای اعمال تغییرات در هر چرخه فریم
  }
  

### 4. FixedUpdate:
- توضیح: این متد در هر چرخه فیکس شده (fixed frame) فراخوانی می‌شود. این متد برای اعمال تغییرات مربوط به فیزیک (مثل حرکت با اصطکاک) که ممکن است در هر فریم متفاوت باشند، استفاده می‌شود.
- نمونه کد:

  void FixedUpdate()
  {
      // کدهای اعمال تغییرات در هر چرخه فیکس شده
  }
  

### 5. LateUpdate:
- توضیح: این متد در هر چرخه فریم بعد از اجرای متدهای Update فراخوانی می‌شود. این متد معمولاً برای اعمال تغییراتی استفاده می‌شود که به اطلاعات محاسباتی مربوط به فریم فعلی وابسته‌اند.
- نمونه کد:

  void LateUpdate()
  {
      // کدهای اعمال تغییرات پس از اجرای Update
  }
  

### 6. OnDestroy:
- توضیح: این متد در هنگام از بین رفتن اجزاء (مثل حذف یک شیء از صحنه) فراخوانی می‌شود. این متد برای اجرای کد مرتبط با تمیز کردن منابع و حالت‌ها مفید است.
- نمونه کد:

  void OnDestroy()
  {
      // کدهای تمیز کردن منابع و اطلاعات
  }
  

این متدها بخشی از چرخه حیات اجزاء در Unity را تشکیل می‌دهند و به توسعه‌دهندگان این امکان را می‌دهند که کدهای مربوط به اجزاء را در لحظات مختلف اجرا کنند.

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

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

### 1. OnEnable:
- توضیح: این متد زمانی صدا زده می‌شود که اجزا (مثل یک اسکریپت) فعال شوند. این ایده‌آل برای اجرای کدهایی که باید زمانی اجرا شوند که یک اجزا (مثل یک اسکریپت) فعال شود، مناسب است.
- نمونه کد:

  void OnEnable()
  {
      // کدهای اجرا شده هنگامی که اجزا فعال می‌شوند
  }
  

### 2. OnDisable:
- توضیح: این متد زمانی صدا زده می‌شود که اجزا غیرفعال می‌شوند. این ایده‌آل برای تمیز کردن یا انجام عملیاتی قبل از غیرفعال شدن یک اجزا است.
- نمونه کد:

  void OnDisable()
  {
      // کدهای اجرا شده هنگامی که اجزا غیرفعال می‌شوند
  }
  

### 3. OnValidate:
- توضیح: این متد زمانی صدا زده می‌شود که اجزا (مثل یک اسکریپت) در ویرایشگر Unity تغییر کرده و نیاز به اعتبارسنجی دارند. معمولاً برای اطمینان از صحت داده‌ها و اعمال تغییرات مرتبط با آن‌ها استفاده می‌شود.
- نمونه کد:

  void OnValidate()
  {
      // کدهای اجرا شده هنگام اعتبارسنجی اجزا
  }
  

### 4. OnApplicationQuit:
- توضیح: این متد زمانی صدا زده می‌شود که کاربر بازی را قبل از خروج از بازی انجام دهد. این متد معمولاً برای انجام تمیزکارها (مثل ذخیره اطلاعات) در هنگام خروج از بازی استفاده می‌شود.
- نمونه کد:

  void OnApplicationQuit()
  {
      // کدهای اجرا شده هنگام خروج از بازی
  }
  

### 5. OnApplicationFocus:
- توضیح: این متد زمانی صدا زده می‌شود که برنامه فوکوس می‌شود یا از فوکوس خارج می‌شود. معمولاً برای مدیریت عملکرد و اعمال تغییراتی که ممکن است با ورود یا خروج از فوکوس مرتبط باشند استفاده می‌شود.
- نمونه کد:

  void OnApplicationFocus(bool hasFocus)
  {
      if (hasFocus)
      {
          // کدهای اجرا شده هنگامی که برنامه فوکوس دارد
      }
      else
      {
          // کدهای اجرا شده هنگامی که برنامه از فوکوس خارج می‌شود
      }
  }
  

### 6. OnApplicationPause:


- توضیح: این متد زمانی صدا زده می‌شود که برنامه وارد حالت توقف (Pause) می‌شود. معمولاً برای مدیریت عملکرد و اعمال تغییرات مرتبط با ورود یا خروج از حالت توقف مورد استفاده قرار می‌گیرد.
- نمونه کد:

  void OnApplicationPause(bool isPaused)
  {
      if (isPaused)
      {
          // کدهای اجرا شده هنگامی که برنامه وارد حالت توقف می‌شود
      }
      else
      {
          // کدهای اجرا شده هنگامی که برنامه از حالت توقف خارج می‌شود
      }
  }
  

این متدها برخی از Callback Methods مهم در Unity هستند و می‌توانند برای ایجاد تعاملات مختلف در طول اجرای بازی مورد استفاده قرار گیرند.

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

درود دوستان عزیز، امیدوارم حالتون عالی باشه.

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

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

1. Singleton Pattern (الگوی تک نمونه):
این الگو به توسعه‌دهندگان کمک می‌کند تا یک نمونه از یک کلاس را فقط یک بار ایجاد کنند و سپس از این نمونه به عنوان نقطه دسترسی به آن کلاس استفاده کنند. این الگو معمولاً برای مواردی مانند مدیریت داده‌های عمومی (مانند مدیر صدا یا مدیر اسکریپت) استفاده می‌شود.

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

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

4. State Pattern (الگوی وضعیت):
این الگو به توسعه‌دهندگان کمک می‌کند تا رفتارهای مختلف یک شیء را در وضعیت‌های مختلف تعریف کنند. به این ترتیب، هرگاه وضعیت یک شیء تغییر کند، رفتار آن نیز تغییر می‌کند.

اینها تنها چند نمونه از دیزاین پترن‌هایی هستند که می‌توانید در Unity استفاده کنید. بسته به نیازهای پروژه خود، ممکن است به دیگر الگوها و رویکردهای معماری هم پی ببرید.

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

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

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

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

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

الگوی کارخانه (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();
    }
}

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

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

الگوی وضعیت (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
}

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