कस्टम Coroutines एकता में वरीयता और शिष्टाचार के साथ

आप पहले से ही इतने शांत हैं कि आप एक ही समय में सभी कुल्हाड़ियों के चारों ओर कोआउट करते हैं, आपकी एक नज़र से वे yield break और आईडीई कैनवास के पीछे छिप जाते हैं। सरल आवरण एक लंबे समय से चले गए चरण हैं।

आप जानते हैं कि उन्हें इतनी अच्छी तरह से कैसे पकाया जाता है कि आप एक मिशेलिन स्टार (या दो भी) प्राप्त कर सकते हैं यदि आपके पास अपना खुद का रेस्तरां है। बेशक! कोर्उटिन सॉस के साथ आपके बुइलाबाइस को चखने से कोई भी उदासीन नहीं होगा।

पूरे एक हफ्ते तक, ठेस में कोड नहीं गिर रहा है! रैपर्स, callback 'और Start/Stop Coroutine गुलामों के बहुत सारे हैं। आपको नियंत्रण और कार्रवाई की स्वतंत्रता की आवश्यकता है। आप अगले चरण पर चढ़ने के लिए तैयार हैं (लेकिन कोर्स से बाहर नहीं निकलें)।

यदि आप इन पंक्तियों में खुद को पहचानते हैं, तो बिल्ली का स्वागत करें।

मैं अपने पसंदीदा पैटर्न - कमांड में से एक को नमस्ते कहने का अवसर लेता हूं।

परिचय

एकता द्वारा प्रदान किए गए सभी yield निर्देशों के लिए ( WaiForSeconds , AsyncOperation , WaiForSeconds और अन्य), आधार वर्ग YieldInstruction ( डॉक्स ) वर्ग है:

 [StructLayout (LayoutKind.Sequential)] [UsedByNativeCode] public class YieldInstruction { } 

हुड के तहत, कोराउटाइन साधारण एन्यूमरेटर ( IEnumerator ( डॉक्स )) हैं। प्रत्येक फ़्रेम को MoveNext() विधि द्वारा कहा जाता है। यदि रिटर्न वैल्यू true , तो अगली yield स्टेटमेंट तक निष्पादन में देरी होती है; यदि false , तो यह बंद हो जाता है।

कस्टम yield निर्देशों के लिए, एकता उसी नाम का CustomYieldInstruction ( डॉक्स ) वर्ग प्रदान करती है।

 public abstract class CustomYieldInstruction : IEnumerator { public abstract bool keepWaiting { get; } public object Current => null; public bool MoveNext(); public void Reset(); } 

यह उससे विरासत में मिला है और KeepWaiting संपत्ति को लागू करने के लिए पर्याप्त है। हमने ऊपर इसके तर्क पर चर्चा की है। यह तब तक true होना चाहिए जब तक कि कोरटाइन को निष्पादित किया जाना है।

प्रलेखन से उदाहरण:

 using UnityEngine; public class WaitForMouseDown : CustomYieldInstruction { public override bool keepWaiting { get { return !Input.GetMouseButtonDown(1); } } public WaitForMouseDown() { Debug.Log("Waiting for Mouse right button down"); } } 

उनके अनुसार, Update() और LateUpdate() बाद Update() प्रत्येक Update() LateUpdate() हर फ्रेम के बाद निष्पादित किया जाता है।

यदि आप उस कोड के साथ काम कर रहे हैं जिसमें कुछ चीजों को एक विशेष क्षण में काम करना चाहिए, और फिर भी इस पृष्ठ का अध्ययन नहीं किया है, तो मैं इस उपलब्धि को तय करने की अत्यधिक अनुशंसा करता हूं।

कस्टम उपज निर्देश

लेकिन हम रेग्युलरइन्डमिशन इनहेरिट CustomYieldInstruction नियमित रैपर के साथ यहां नहीं आए। इसके लिए आप बिना मिशेलिन के भी रह सकते हैं।

इसलिए हम प्रलेखन को और अधिक धूम्रपान करते हैं और लगभग उसी पृष्ठ के नीचे हम सबसे महत्वपूर्ण पैराग्राफ पाते हैं।

अधिक नियंत्रण और अधिक जटिल उपज निर्देशों को लागू करने के लिए आप सीधे System.Collections.IEnumerator वर्ग से इनहेरिट कर सकते हैं । इस स्थिति में, MoveNext() पद्धति को उसी तरह से लागू करें जिस तरह से आप रखने keepWaiting संपत्ति को लागू करेंगे । इसके अतिरिक्त, आप Current प्रॉपर्टी में एक ऑब्जेक्ट भी लौटा सकते हैं, जिसे मूवनेक्स्ट MoveNext() विधि को अंजाम देने के बाद यूनिटी के कोरटाइन शेड्यूलर द्वारा प्रोसेस किया जाएगा । इसलिए उदाहरण के लिए यदि Current IEnumerator से विरासत में मिली दूसरी वस्तु को IEnumerator , तो जब तक लौटाया हुआ एक पूरा नहीं हो जाता, तब तक वर्तमान गणनाकर्ता निलंबित रहेगा।

पवित्र कुलों! ये नियंत्रण और कार्रवाई की स्वतंत्रता है जो मैं बहुत चाहता था। खैर यह बात है, अब आप इतने कोरटीन लपेटेंगे कि कोई भी गिमबल लॉक डरावना नहीं है। मुख्य बात, खुशी से, लंबू से टकराकर धमाका न करना।

इंटरफ़ेस

खैर, यह तय करना अच्छा होगा कि हमारे निर्देश के साथ बातचीत का कौन सा इंटरफ़ेस हम चाहते हैं। कुछ न्यूनतम सेट।

मैं निम्नलिखित विकल्प का सुझाव देता हूं

 public interface IInstruction { bool IsExecuting { get; } bool IsPaused { get; } Instruction Execute(); void Pause(); void Resume(); void Terminate(); event Action<Instruction> Started; event Action<Instruction> Paused; event Action<Instruction> Cancelled; event Action<Instruction> Done; } 

मैं इस तथ्य पर आपका ध्यान आकर्षित करना चाहता हूं कि IsExecuting और IsPaused यहां विपरीत नहीं हैं। यदि कोरटाइन के निष्पादन को रोक दिया जाता है, तो इसे अभी भी निष्पादित किया जा रहा है।

त्यागी और सौजन्य

जैसा कि प्रलेखन कहता है, आपको IEnumerator इंटरफ़ेस को लागू करने की आवश्यकता है। कुछ स्थानों पर, अब के लिए, स्टब्स को छोड़ दें, क्योंकि इसका कार्यान्वयन सीधे निर्भर करता है कि हम इसे किस कार्यक्षमता में लाना चाहते हैं।

 using UnityEngine; using IEnumerator = System.Collections.IEnumerator; public abstract class Instruction : IEnumerator { private Instruction current; object IEnumerator.Current => current; void IEnumerator.Reset() { } bool IEnumerator.MoveNext() { } } 

यह विचार करने योग्य है कि हमारे निर्देश को कम से कम दो तरीके से लॉन्च किया जा सकता है:

1. StartCoroutine(IEnumerator routine) विधि StartCoroutine(IEnumerator routine) :

   
   

    StartCoroutine(new ConcreteInstruction()); 

   
   

2. उपज yield :

   
   

    private IEnumerator SomeRoutine() { yield return new ConcreteInstruction(); } 

   
   

Execute पद्धति, जिसे हमने IInstruction इंटरफ़ेस में ऊपर वर्णित किया है, पहली विधि का उपयोग करेगी। इसलिए, हम कुछ क्षेत्रों को जोड़ते हैं जो इस मामले में निर्देश का प्रबंधन करने में मदद करेंगे।

 private object routine; public MonoBehaviour Parent { get; private set; } 

अब गुण और IInstruction लिए घटनाओं।

 using UnityEngine; using System; using IEnumerator = System.Collections.IEnumerator; public abstract class Instruction : IEnumerator, IInstruction { private Instruction current; object IEnumerator.Current => current; private object routine; public MonoBehaviour Parent { get; private; } public bool IsExecuting { get; private set; } public bool IsPaused { get; private set; } private bool IsStopped { get; set; } public event Action<Instruction> Started; public event Action<Instruction> Paused; public event Action<Instruction> Terminated; public event Action<Instruciton> Done; void IEnumerator.Reset() { } bool IEnumerator.MoveNext() { } Instruction(MonoBehaviour parent) => Parent = parent; } 

इसके अलावा, बाल वर्गों में घटनाओं से निपटने के लिए तरीके:

 protected virtual void OnStarted() { } protected virtual void OnPaused() { } protected virtual void OnResumed() { } protected virtual void OnTerminated() { } protected virtual void OnDone() { } 

बच्चे को उनके प्रसंस्करण की प्राथमिकता देने के लिए संबंधित घटनाओं से ठीक पहले उन्हें मैन्युअल रूप से बुलाया जाएगा।

अब शेष विधियाँ।

 public void Pause() { if (IsExecuting && !IsPaused) { IsPaused = true; OnPaused(); Paused?.Invoke(this); } } public bool Resume() { if (IsExecuting) { IsPaused = false; OnResumed(); } } 

यहां सब कुछ सरल है। निर्देश को केवल तभी रोका जा सकता है जब उसे निष्पादित किया जा रहा है और यदि उसे निलंबित नहीं किया गया है, और केवल निलंबित रहने पर निष्पादन जारी रखें।

 public void Terminate() { if (Stop()) { OnTerminated(); Terminate?.Invoke(this); } } private bool Stop() { if (IsExecuting) { if (routine is Coroutine) Parent.StopCoroutine(routine as Coroutine); (this as IEnumerator).Reset(); return IsStopped = true; } return false; } 

निर्देश को रोकने के लिए मुख्य तर्क Stop विधि में बनाया गया है। यह एक मूक स्टॉप (ट्रिगरिंग घटनाओं के बिना) करने में सक्षम होने के लिए आवश्यक है।
यह जाँचना if (routine is Coroutine) आवश्यक है क्योंकि, जैसा कि मैंने ऊपर लिखा है, निर्देश yield (जो कि StartCoroutine को बुलाए बिना) द्वारा शुरू किया जा सकता है, जिसका अर्थ है कि StartCoroutine विशिष्ट उदाहरण के लिए कोई लिंक नहीं हो सकता है। इस मामले में, routine केवल एक ठूंठ होगी।

 public Instruction Execute(MonoBehaviour parent) { if (current != null) { Debug.LogWarning($"Instruction { GetType().Name} is currently waiting for another one and can't be stared right now."); return this; } if (!IsExecuting) { IsExecuting = true; routine = (Parent = parent).StartCoroutine(this); return this; } Debug.LogWarning($"Instruction { GetType().Name} is already executing."); return this; } 

मुख्य लॉन्च विधि भी बेहद सरल है - लॉन्च केवल तभी किया जाएगा जब निर्देश अभी तक लॉन्च नहीं किया गया है।

यह IEnumerator के कार्यान्वयन को पूरा करने के लिए बनी हुई है, क्योंकि हमने कुछ तरीकों में खाली स्थान छोड़ दिए हैं।

 IEnumerator.Reset() { IsExecuting = false; IsPaused = false; IsStopped = false; routine = null; } 

और सबसे दिलचस्प, लेकिन अधिक जटिल नहीं है, MoveNext :

 bool IEnumerator.MoveNext() { if (IsStopped) { (this as IEnumerator).Reset(); return false; } if (!IsExecuting) { IsExecuting = true; routine = new object(); OnStarted(); Started?.Invoke(this); } if (current != null) return true; if (IsPaused) return true; if (!Update()) { OnDone(); Done?.Invoke(this); IsStopped = true; return false; } return true; } 

if (!IsExecuting) - यदि निर्देश StartCoroutine माध्यम से लॉन्च नहीं किया गया था, और कोड की इस लाइन को निष्पादित किया गया है, तो yield ने इसे लॉन्च किया। हम routine और आग की घटनाओं में एक ठूंठ लिखते हैं।

if (current != null) - current इस्तेमाल बच्चे के निर्देशों के लिए किया जाता है। अगर अचानक यह सामने आया है, तो हम इसके खत्म होने का इंतजार कर रहे हैं। कृपया ध्यान दें कि मैं इस लेख में बच्चे के निर्देशों के लिए समर्थन जोड़ने की प्रक्रिया को याद करूंगा ताकि इसे और अधिक न बढ़ाया जाए। इसलिए, यदि आप इस कार्यक्षमता को आगे बढ़ाने में रुचि नहीं रखते हैं, तो आप बस इन पंक्तियों को हटा सकते हैं।

if (!Update()) - हमारे निर्देशों में Update विधि, keepWaiting तरह ही काम करती CustomYieldInstruction और इसे बाल वर्ग में लागू किया जाना चाहिए। Instruction मात्र एक अमूर्त विधि है।

 protected abstract bool Update(); 

 using UnityEngine; using System; using IEnumerator = System.Collections.IEnumerator; public abstract class Instruction : IEnumerator, IInstruction { private Instruction current; object IEnumerator.Current => current; private object routine; public MonoBehaviour Parent { get; private set; } public bool IsExecuting { get; private set; } public bool IsPaused { get; private set; } private bool IsStopped { get; set; } public event Action<Instruction> Started; public event Action<Instruction> Paused; public event Action<Instruction> Terminated; public event Action<Instruction> Done; void IEnumerator.Reset() { IsPaused = false; IsStopped = false; routine = null; } bool IEnumerator.MoveNext() { if (IsStopped) { (this as IEnumerator).Reset(); return false; } if (!IsExecuting) { IsExecuting = true; routine = new object(); OnStarted(); Started?.Invoke(this); } if (current != null) return true; if (IsPaused) return true; if (!Update()) { OnDone(); Done?.Invoke(this); IsStopped = true; return false; } return true; } protected Instruction(MonoBehaviour parent) => Parent = parent; public void Pause() { if (IsExecuting && !IsPaused) { IsPaused = true; OnPaused(); Paused?.Invoke(this); } } public void Resume() { IsPaused = false; OnResumed(); } public void Terminate() { if (Stop()) { OnTerminated(); Terminated?.Invoke(this); } } private bool Stop() { if (IsExecuting) { if (routine is Coroutine) Parent.StopCoroutine(routine as Coroutine); (this as IEnumerator).Reset(); return IsStopped = true; } return false; } public Instruction Execute() { if (current != null) { Debug.LogWarning($"Instruction { GetType().Name} is currently waiting for another one and can't be stared right now."); return this; } if (!IsExecuting) { IsExecuting = true; routine = Parent.StartCoroutine(this); return this; } Debug.LogWarning($"Instruction { GetType().Name} is already executing."); return this; } public Instruction Execute(MonoBehaviour parent) { if (current != null) { Debug.LogWarning($"Instruction { GetType().Name} is currently waiting for another one and can't be stared right now."); return this; } if (!IsExecuting) { IsExecuting = true; routine = (Parent = parent).StartCoroutine(this); return this; } Debug.LogWarning($"Instruction { GetType().Name} is already executing."); return this; } public void Reset() { Terminate(); Started = null; Paused = null; Terminated = null; Done = null; } protected virtual void OnStarted() { } protected virtual void OnPaused() { } protected virtual void OnResumed() { } protected virtual void OnTerminated() { } protected virtual void OnDone() { } protected abstract bool Update(); } 

उदाहरण

बेस क्लास तैयार है। किसी भी निर्देश को बनाने के लिए, यह उसे विरासत में देना और आवश्यक सदस्यों को लागू करना पर्याप्त है। मैं कुछ उदाहरणों पर एक नज़र डालने का सुझाव देता हूं।

बिंदु पर ले जाएँ

 public sealed class MoveToPoint : Instruction { public Transform Transform { get; set; } public Vector3 Target { get; set; } public float Speed { get; set; } public float Threshold { get; set; } public MoveToPoint(MonoBehaviour parent) : base(parent) { } protected override bool Update() { Transform.position = Vector3.Lerp(Transform.position, Target, Time.deltaTime * Speed); return Vector3.Distance(Transform.position, Target) >= Threshold; } } 

 private void Method() { var move = new MoveToPoint(this) { Actor = transform, Target = target, Speed = 1.0F, Threshold = 0.05F }; move.Execute(); } 

 private void Method() { var move = new MoveToPoint(this); move.Execute(transform, target, 1.0F, 0.05F); } 

 private IEnumerator Method() { yield return new MoveToPoint(this) { Actor = transform, Target = target, Speed = 1.0F, Threshold = 0.05F }; } 

 private IEnumerator Method() { var move = new MoveToPoint(this) { Actor = transform, Target = target, Speed = 1.0F, Threshold = 0.05F }; yield return move; } 

 private IEnumerator Method() { var move = new MoveToPoint(this); yield return move.Execute(transform, target, 1.0F, 0.05F); } 

इनपुट प्रोसेसिंग

 public sealed class WaitForKeyDown : Instruction { public KeyCode Key { get; set; } protected override bool Update() { return !Input.GetKeyDown(Key); } public WaitForKeyDown(MonoBehaviour parent) : base(parent) { } public Instruction Execute(KeyCode key) { Key = key; return base.Execute(); } } 

 private void Method() { car wait = new WaitForKeyDown(this); wait.Execute(KeyCode.Space).Done += (i) => DoSomething(); } 

 private IEnumerator Method() { yield return new WaitForKeyDown(this) { Key = KeyCode.Space }; // do something; } 

रुकें और रुकें

 public sealed class Wait : Instruction { public float Delay { get; set; } private float startTime; protected override bool Update() { return Time.time - startTime < Delay; } public Wait(MonoBehaviour parent) : base(parent) { } public Wait(float delay, MonoBehaviour parent) : base(parent) { Delay = delay; } protected override void OnStarted() { startTime = Time.time; } public Instruction Execute(float delay) { Delay = delay; return base.Execute(); } } 

यहाँ, ऐसा लगता है, सब कुछ जितना संभव हो उतना सरल है। सबसे पहले, हमने प्रारंभ समय दर्ज किया, और फिर वर्तमान समय और StartTime समय के बीच अंतर की जाँच करें। लेकिन एक अति सूक्ष्म अंतर है जिसे आप तुरंत नोटिस नहीं कर सकते। यदि किसी निर्देश के निष्पादन के दौरान आप इसे रोकते हैं ( Pause विधि का उपयोग करके) और प्रतीक्षा करें, तो फिर से शुरू करने ( Resume ) के बाद इसे तुरंत निष्पादित किया जाएगा। और सभी क्योंकि अब यह निर्देश ध्यान में नहीं आता है कि मैं इसे रोक सकता हूं।

आइए इस अन्याय को ठीक करने का प्रयास करें:

 protected override void OnPaused() { Delay -= Time.time - startTime; } protected override void OnResumed() { startTime = Time.time; } 

हो गया। अब, ठहराव की समाप्ति के बाद, निर्देश को निष्पादित होने में उतना ही समय लगेगा जितना कि इसके शुरू होने से पहले छोड़ा गया था।

 private void Method() { var wait = new Wait(this); wait.Execute(5.0F).Done += (i) => DoSomething; } 

 private IEnumerator Method() { yield return new Wait(this, 5.0F); // do something; } 

संपूर्ण

एकता में Coroutines आप अद्भुत और कार्यात्मक बातें करते हैं। लेकिन वे कितने जटिल होंगे और आपको उनकी आवश्यकता है या नहीं, यह सभी की व्यक्तिगत पसंद है।

कोरटीन की कार्यक्षमता का विस्तार करना सबसे मुश्किल काम नहीं है। आपको बस यह तय करने की जरूरत है कि आप किस इंटरफेस के साथ बातचीत करना चाहते हैं और उनके काम का एल्गोरिदम क्या होगा।

आपके समय के लिए धन्यवाद। अपने प्रश्नों / टिप्पणियों / टिप्पणियों को टिप्पणी में छोड़ दें। मुझे संवाद करने में खुशी होगी।

PS अगर, अचानक, आप corutin का उपयोग करने के बारे में जल गए, तो इस टिप्पणी को पढ़ें और कुछ ठंडा पीएं।