एकता में कमांड डिजाइन पैटर्न को लागू करना

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

रणनीति गेम में पूर्ववत और फिर से कार्य करने के लिए कमांड टेम्पलेट भी उपयोगी है।

इस ट्यूटोरियल में, हम C # में कमांड टेम्प्लेट को कार्यान्वित करते हैं और इसका उपयोग तीन-आयामी भूलभुलैया के माध्यम से बॉट चरित्र को निर्देशित करने के लिए करते हैं। ट्यूटोरियल से आप सीखेंगे:

• कमांड पैटर्न की मूल बातें।
• कमांड पैटर्न कैसे लागू करें
• इनपुट कमांड की एक कतार कैसे बनाएं और उनके निष्पादन में देरी करें।

नोट : यह माना जाता है कि आप पहले से ही एकता से परिचित हैं और C # का औसत ज्ञान है। इस ट्यूटोरियल में हम एकता 2019.1 और C # 7 के साथ काम करेंगे।

काम पर लगना

आरंभ करने के लिए, परियोजना सामग्री डाउनलोड करें। फ़ाइल खोलना और एकता में स्टार्टर परियोजना खोलें।

आरडब्ल्यू / दृश्यों पर जाएं और मुख्य दृश्य खोलें। दृश्य में एक बॉट और एक भूलभुलैया है, साथ ही एक टर्मिनल यूआई है जो निर्देश प्रदर्शित करता है। स्तर का डिज़ाइन एक ग्रिड के रूप में बनाया गया है, जो उपयोगी है जब हम बॉट को भूलभुलैया के माध्यम से स्थानांतरित करते हैं।


यदि आप Play पर क्लिक करते हैं, तो हम देखेंगे कि निर्देश काम नहीं करते हैं। यह सामान्य है क्योंकि हम इस कार्यक्षमता को ट्यूटोरियल में जोड़ देंगे।

दृश्य का सबसे दिलचस्प हिस्सा गेमऑबजेक्ट बॉट है । उस पर क्लिक करके इसे पदानुक्रम विंडो में चुनें।


इंस्पेक्टर में, आप देख सकते हैं कि इसमें बॉट घटक है। हम इस घटक का उपयोग इनपुट कमांड जारी करके करेंगे।

हम बॉट के तर्क को समझते हैं

आरडब्ल्यू / लिपियों पर जाएं और कोड संपादक में बॉट स्क्रिप्ट खोलें। आपको बॉट लिपि में क्या हो रहा है, यह जानने की आवश्यकता नहीं है। लेकिन दो तरीकों पर एक नज़र डालें: Move और Shoot । फिर, आपको यह पता लगाने की ज़रूरत नहीं है कि इन विधियों के अंदर क्या चल रहा है, लेकिन आपको यह समझने की आवश्यकता है कि उनका उपयोग कैसे करें।

ध्यान दें कि Move विधि एक इनपुट पैरामीटर CardinalDirection प्राप्त करती है। CardinalDirection एक गणन है। CardinalDirection का एक गणन तत्व Up , Down , Right या Left । चयनित CardinalDirection आधार पर CardinalDirection बॉट संबंधित दिशा में ग्रिड के साथ ठीक एक वर्ग चलता है।


Shoot विधि बॉट को आग के गोले दागने के लिए मजबूर करती है जो पीली दीवारों को नष्ट कर देती है, लेकिन अन्य दीवारों के खिलाफ बेकार हैं।


अंत में, ResetToLastCheckpoint विधि पर एक नज़र डालें; समझने के लिए कि वह क्या कर रहा है, भूलभुलैया को देखें। चौकी में डॉट्स हैं जिन्हें चौकी कहा जाता है । भूलभुलैया को पारित करने के लिए, बॉट को हरे रंग के नियंत्रण बिंदु तक पहुंचने की आवश्यकता होती है।


जब एक बॉट एक नए नियंत्रण बिंदु पर कदम रखता है, तो यह उसके लिए अंतिम हो जाता है। ResetToLastCheckpoint बॉट की स्थिति को रीसेट करता है, इसे अंतिम नियंत्रण बिंदु पर ले जाता है।


जब तक हम इन विधियों का उपयोग नहीं कर सकते, हम इसे जल्द ही ठीक कर लेंगे। आरंभ करने के लिए, आपको कमांड डिज़ाइन पैटर्न के बारे में जानने की आवश्यकता है।

कमांड डिजाइन पैटर्न क्या है?

कमांड पैटर्न डिजाइन पैटर्न में वर्णित 23 डिज़ाइन पैटर्न में से एक है : एरीच गामा, रिचर्ड हेल्म, राल्फ जॉनसन और जॉन व्लिसाइड्स ( जीओएफ , गैंग ऑफ़ फोर) द्वारा गैंग ऑफ़ फोर द्वारा लिखित पुन: प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर बुक के तत्व ।

लेखकों की रिपोर्ट है कि "कमांड पैटर्न एक वस्तु के रूप में अनुरोध को एनकोड करता है, इस प्रकार हमें अन्य वस्तुओं को अलग-अलग अनुरोधों, कतार या लॉग अनुरोधों के साथ परिचालित करने और प्रतिवर्ती संचालन का समर्थन करने की अनुमति देता है।"

वाह! वह कैसे है?

मैं समझता हूं कि यह परिभाषा बहुत सरल नहीं है, इसलिए इसका विश्लेषण करते हैं।

एनकैप्सुलेशन का मतलब है कि एक विधि कॉल को ऑब्जेक्ट के रूप में एनकैप्सुलेट किया जा सकता है।


इनकैप्सूलेटेड विधि इनपुट पैरामीटर के आधार पर कई ऑब्जेक्ट्स को प्रभावित कर सकती है। इसे अन्य वस्तुओं का पैरामीटराइजेशन कहा जाता है।

परिणामी "कमांड" को अन्य टीमों के साथ तब तक बचाया जा सकता है जब तक कि उन्हें निष्पादित नहीं किया जाता है। यह अनुरोध कतार है ।


टीम कतार

अंत में, प्रतिवर्तीता का मतलब है कि ऑपरेशन को पूर्ववत फ़ंक्शन का उपयोग करके वापस किया जा सकता है।

ठीक है, लेकिन यह कोड में कैसे दर्शाता है?

कमांड क्लास में एक एक्सक्यूट विधि होगी, जो इनपुट पैरामीटर के रूप में प्राप्त होती है (जिसे कमांड निष्पादित किया जाता है) जिसे रिसीवर कहा जाता है। यही है, वास्तव में, निष्पादित विधि कमांड वर्ग द्वारा समझाया गया है।

कमांड क्लास के कई उदाहरणों को साधारण वस्तुओं के रूप में पारित किया जा सकता है, अर्थात, उन्हें डेटा संरचनाओं जैसे कि कतार, स्टैक, आदि में संग्रहीत किया जा सकता है।

किसी कमांड को निष्पादित करने के लिए, आपको इसकी निष्पादन विधि को कॉल करना होगा। निष्पादन शुरू करने वाले वर्ग को इनोकर कहा जाता है।

वर्तमान में इस परियोजना में एक खाली वर्ग है जिसे BotCommand कहा जाता है। अगले भाग में, हम बॉट को कमांड टेम्प्लेट का उपयोग करके कार्य करने की अनुमति देने के लिए ऊपर के कार्यान्वयन को लागू करेंगे।

बॉट को स्थानांतरित करें

कमांड पैटर्न कार्यान्वयन

इस खंड में, हम कमांड पैटर्न को लागू करते हैं। इसे लागू करने के कई तरीके हैं। इस ट्यूटोरियल में हम उनमें से एक को कवर करेंगे।

आरंभ करने के लिए, आरडब्ल्यू / लिपियों पर जाएं और संपादक में बोटकमैंड स्क्रिप्ट खोलें। BotCommand वर्ग अभी भी खाली है, लेकिन लंबे समय के लिए नहीं।

निम्नलिखित कोड को कक्षा में डालें:

  //1 private readonly string commandName; //2 public BotCommand(ExecuteCallback executeMethod, string name) { Execute = executeMethod; commandName = name; } //3 public delegate void ExecuteCallback(Bot bot); //4 public ExecuteCallback Execute { get; private set; } //5 public override string ToString() { return commandName; } 

यहाँ क्या हो रहा है?

1. commandName वैरिएबल commandName उपयोग मानव-पठनीय कमांड नाम को स्टोर करने के लिए किया जाता है। टेम्पलेट में इसका उपयोग करना आवश्यक नहीं है, लेकिन हमें बाद में ट्यूटोरियल में इसकी आवश्यकता होगी।
2. BotCommand के BotCommand एक फ़ंक्शन और एक स्ट्रिंग प्राप्त करता है। यह हमें कमांड ऑब्जेक्ट की Execute विधि और उसके name सेट करने में मदद करेगा।
3. ExecuteCallback प्रतिनिधि ExecuteCallback विधि के प्रकार को परिभाषित करता है। इनकैप्सूलेटेड विधि शून्य वापस आ जाएगी और इनपुट पैरामीटर के रूप में टाइप Bot (घटक बॉट ) का एक ऑब्जेक्ट स्वीकार करेगी।
4. Execute संपत्ति, एन्कैप्सुलेटेड विधि को संदर्भित करेगी। हम इसका उपयोग एन्कैप्सुलेटेड विधि को कॉल करने के लिए करेंगे।
5. स्ट्रिंग commandName को वापस करने के लिए ToString विधि को ओवरराइड किया जाता है। यह सुविधाजनक है, उदाहरण के लिए, यूआई में उपयोग के लिए।

परिवर्तन सहेजें और यह बात है! हमने सफलतापूर्वक कमांड पैटर्न लागू किया है।

इसका उपयोग करना बाकी है।

टीम बिल्डिंग

RW / लिपियों फ़ोल्डर में BotInputHandler खोलें।

यहाँ हम BotCommand पाँच उदाहरण BotCommand । ये उदाहरण गेमऑबजेक्ट बॉट को ऊपर, नीचे, बाएं और दाएं और साथ ही शूटिंग के लिए स्थानांतरित करने के तरीकों को एन्क्रिप्ट करेंगे।

इसे लागू करने के लिए, इस वर्ग में निम्नलिखित डालें:

  //1 private static readonly BotCommand MoveUp = new BotCommand(delegate (Bot bot) { bot.Move(CardinalDirection.Up); }, "moveUp"); //2 private static readonly BotCommand MoveDown = new BotCommand(delegate (Bot bot) { bot.Move(CardinalDirection.Down); }, "moveDown"); //3 private static readonly BotCommand MoveLeft = new BotCommand(delegate (Bot bot) { bot.Move(CardinalDirection.Left); }, "moveLeft"); //4 private static readonly BotCommand MoveRight = new BotCommand(delegate (Bot bot) { bot.Move(CardinalDirection.Right); }, "moveRight"); //5 private static readonly BotCommand Shoot = new BotCommand(delegate (Bot bot) { bot.Shoot(); }, "shoot"); 

इन प्रत्येक उदाहरणों में, एक अनाम विधि को कंस्ट्रक्टर को पास किया जाता है। यह अनाम विधि संबंधित कमांड ऑब्जेक्ट के अंदर समझाया जाएगा। जैसा कि आप देख सकते हैं, प्रत्येक गुमनाम तरीकों के हस्ताक्षर ExecuteCallback प्रतिनिधि द्वारा निर्दिष्ट आवश्यकताओं को पूरा करते हैं।

इसके अलावा, कंस्ट्रक्टर का दूसरा पैरामीटर एक स्ट्रिंग है जो कमांड के नाम को दर्शाता है। यह नाम आदेश उदाहरण के ToString विधि द्वारा वापस आ जाएगा। बाद में हम इसे UI के लिए लागू करेंगे।

पहले चार उदाहरणों में, अनाम विधियां bot ऑब्जेक्ट पर Move विधि को कॉल करती हैं। हालांकि, उनके इनपुट पैरामीटर अलग हैं।

MoveUp , MoveDown , MoveLeft और MoveRight , MoveLeft CardinalDirection.Right . MoveRight , CardinalDirection.Down , CardinalDirection.Left और CardinalDirection.Right पास मापदंडों को पास करते हैं। जैसा कि कमांड डिजाइन पैटर्न सेक्शन में बताया गया है, वे गेमऑबजेक्ट बॉट को स्थानांतरित करने के लिए अलग-अलग दिशाओं का संकेत देते हैं।

पांचवें उदाहरण में, अनाम विधि bot ऑब्जेक्ट के लिए Shoot विधि को कॉल करती है। इसके लिए धन्यवाद, बॉट कमांड के निष्पादन के दौरान एक गोला दागेगा।

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

ऐसा करने के लिए, कमांड इंस्टैंस के तुरंत बाद, BotInputHandler में निम्नलिखित कोड BotInputHandler :

  public static BotCommand HandleInput() { if (Input.GetKeyDown(KeyCode.W)) { return MoveUp; } else if (Input.GetKeyDown(KeyCode.S)) { return MoveDown; } else if (Input.GetKeyDown(KeyCode.D)) { return MoveRight; } else if (Input.GetKeyDown(KeyCode.A)) { return MoveLeft; } else if (Input.GetKeyDown(KeyCode.F)) { return Shoot; } return null; } 

HandleInput विधि उपयोगकर्ता द्वारा दबाए गए कुंजी के आधार पर कमांड का एक उदाहरण देता है। आगे बढ़ने से पहले अपने परिवर्तनों को सहेजें।

आज्ञाओं को लागू करना

महान, अब हमारे द्वारा बनाई गई टीमों का उपयोग करने का समय है। आरडब्ल्यू / लिपियों पर फिर से जाएं और संपादक में दृश्य प्रबंधक स्क्रिप्ट खोलें। इस वर्ग में, आप एक प्रकार के UIManager चर के एक uiManager चर के लिए एक नोटिस देखेंगे।

UIManager वर्ग टर्मिनल UI के लिए उपयोगी सहायक तरीके प्रदान करता है जो हम इस दृश्य में उपयोग करते हैं। यदि UIManager से विधि का उपयोग किया जाता है, तो ट्यूटोरियल समझाएगा कि यह क्या करता है, लेकिन हमारे उद्देश्यों के लिए सामान्य रूप से इसकी आंतरिक संरचना को जानना आवश्यक नहीं है।

इसके अलावा, bot चर गेमऑबजेक्ट बॉट से जुड़े बॉट घटक को संदर्भित करता है।

अब निम्न कोड को SceneManager वर्ग में जोड़ें, इसे टिप्पणी //1 प्रतिस्थापित करें:

  //1 private List<BotCommand> botCommands = new List<BotCommand>(); private Coroutine executeRoutine; //2 private void Update() { if (Input.GetKeyDown(KeyCode.Return)) { ExecuteCommands(); } else { CheckForBotCommands(); } } //3 private void CheckForBotCommands() { var botCommand = BotInputHandler.HandleInput(); if (botCommand != null && executeRoutine == null) { AddToCommands(botCommand); } } //4 private void AddToCommands(BotCommand botCommand) { botCommands.Add(botCommand); //5 uiManager.InsertNewText(botCommand.ToString()); } //6 private void ExecuteCommands() { if (executeRoutine != null) { return; } executeRoutine = StartCoroutine(ExecuteCommandsRoutine()); } private IEnumerator ExecuteCommandsRoutine() { Debug.Log("Executing..."); //7 uiManager.ResetScrollToTop(); //8 for (int i = 0, count = botCommands.Count; i < count; i++) { var command = botCommands[i]; command.Execute(bot); //9 uiManager.RemoveFirstTextLine(); yield return new WaitForSeconds(CommandPauseTime); } //10 botCommands.Clear(); bot.ResetToLastCheckpoint(); executeRoutine = null; } 

वाह, कितना कोड! लेकिन चिंता मत करो; हम अंततः गेम विंडो में प्रोजेक्ट के पहले वास्तविक लॉन्च के लिए तैयार हैं।

मैं बाद में कोड समझाऊंगा। परिवर्तनों को सहेजना याद रखें।

कमांड टेम्प्लेट का परीक्षण करने के लिए गेम चलाना

तो अब निर्माण का समय है; एकता संपादक में प्ले पर क्लिक करें।

आपको WASD कुंजी का उपयोग करके चाल कमांड दर्ज करने में सक्षम होना चाहिए। शूटिंग कमांड दर्ज करने के लिए, एफ कुंजी दबाएं। कमांड निष्पादित करने के लिए, Enter दबाएं ।

नोट : जब तक निष्पादन की प्रक्रिया पूरी नहीं हो जाती है, तब तक नए कमांड दर्ज करना संभव नहीं है।

ध्यान दें कि लाइनें टर्मिनल UI में जोड़ी जाती हैं। UI में टीमों को उनके नामों से दर्शाया गया है। यह commandName वैरिएबल के लिए संभव बनाया गया है।

इसके अलावा, ध्यान दें कि निष्पादन से पहले UI कैसे स्क्रॉल करता है और निष्पादन के दौरान लाइनें कैसे हटाई जाती हैं।

हम टीमों का अधिक बारीकी से अध्ययन करते हैं

यह उस कोड को सीखने का समय है जिसे हमने "लागू कमांड" खंड में जोड़ा है:

1. botCommands सूची botCommands उदाहरणों के लिए लिंक स्टोर BotCommand । याद रखें कि स्मृति को बचाने के लिए, हम केवल पाँच उदाहरण बना सकते हैं, लेकिन एक कमांड के कई संदर्भ हो सकते हैं। इसके अतिरिक्त, executeCoroutine चर ExecuteCommandsRoutine को संदर्भित करता है, जो कमांड के निष्पादन को नियंत्रित करता है।
2. यदि उपयोगकर्ता ने कुंजी दर्ज की है, तो Update जांच करें; यदि हां, तो यह ExecuteCommands कॉल करता है, अन्यथा CheckForBotCommands को CheckForBotCommands ।
3. CheckForBotCommands यूजर ने इनपुट पूरा कर लिया है या नहीं, यह BotInputHandler लिए BotInputHandler से स्टैटिक HandleInput विधि का उपयोग करता है, और यदि ऐसा है, तो कमांड वापस आ जाती है । दी गई कमांड को AddToCommands पास किया AddToCommands । हालाँकि, यदि कमांड निष्पादित होते हैं, अर्थात्। यदि executeRoutine शून्य नहीं है, तो यह AddToCommands कुछ भी पास किए बिना वापस आ जाएगा। यही है, उपयोगकर्ता को पूरा होने तक इंतजार करना होगा।
4. AddToCommands में कमांड के दिए गए इंस्टेंस में एक नया लिंक जोड़ता है।
5. InsertNewText वर्ग की InsertNewText विधि टर्मिनल UI पर पाठ की एक नई पंक्ति जोड़ती है। एक पाठ स्ट्रिंग एक इनपुट पैरामीटर के रूप में पारित एक स्ट्रिंग है। इस मामले में, हम commandName कमांडनाम देते हैं।
6. ExecuteCommands विधि ExecuteCommands लॉन्च करती है।
7. ResetScrollToTop से UIManager टर्मिनल UI को स्क्रॉल करता है। यह निष्पादन की शुरुआत से ठीक पहले किया जाता है।
8. ExecuteCommandsRoutine में एक लूप होता है जो botCommands लिस्ट के अंदर कमांड्स पर botCommands और उन्हें एक-एक करके निष्पादित करता है, bot ऑब्जेक्ट को Execute प्रॉपर्टी द्वारा लौटाए गए तरीके से पास करता है। प्रत्येक निष्पादन के बाद, CommandPauseTime में एक पॉज़ जोड़ा जाता है।
9. RemoveFirstTextLine से RemoveFirstTextLine विधि टर्मिनल UI में मौजूद टेक्स्ट की पहली पंक्ति को हटा देती है, यदि वह मौजूद है। यानी जब कोई कमांड निष्पादित होती है, तो उसका नाम UI से हटा दिया जाता है।
10. सभी आदेशों के botCommands होने के बाद botCommands को साफ़ कर दिया जाता है और ResetToLastCheckpoint का उपयोग करके बॉट को अंतिम ब्रेकपॉइंट पर रीसेट कर ResetToLastCheckpoint । अंत में, executeRoutine null और उपयोगकर्ता कमांड दर्ज करना जारी रख सकता है।

पूर्ववत और फिर से सुविधाओं को लागू करना

फिर से दृश्य को चलाएं और हरे रंग के नियंत्रण बिंदु तक पहुंचने का प्रयास करें।

आप देखेंगे कि जब हम दर्ज कमांड को रद्द नहीं कर सकते। इसका मतलब यह है कि यदि आप कोई गलती करते हैं, तो आप वापस नहीं जा सकते हैं जब तक कि आप अपने द्वारा दर्ज सभी आदेशों को पूरा नहीं करते हैं। आप इसे Undo और Redo सुविधाओं को जोड़कर ठीक कर सकते हैं।

SceneManager.cs पर वापस जाएं और botCommands के लिए सूची घोषणा के तुरंत बाद निम्नलिखित चर घोषणा को botCommands :

  private Stack<BotCommand> undoStack = new Stack<BotCommand>(); 

undoStack चर एक संग्रह (संग्रह परिवार से) है जो सभी संदर्भों को पूर्ववत् किया जा सकता है।

अब हम दो तरीके UndoCommandEntry और RedoCommandEntry जो पूर्ववत और फिर से निष्पादित होंगे। SceneManager वर्ग में, ExecuteCommandsRoutine के बाद निम्न कोड SceneManager :

  private void UndoCommandEntry() { //1 if (executeRoutine != null || botCommands.Count == 0) { return; } undoStack.Push(botCommands[botCommands.Count - 1]); botCommands.RemoveAt(botCommands.Count - 1); //2 uiManager.RemoveLastTextLine(); } private void RedoCommandEntry() { //3 if (undoStack.Count == 0) { return; } var botCommand = undoStack.Pop(); AddToCommands(botCommand); } 

आइए कोड का विश्लेषण करें:

1. यदि आदेश निष्पादित होते हैं या botCommands सूची खाली है, तो UndoCommandEntry विधि कुछ नहीं करती है। अन्यथा, यह undoStack स्टैक पर दर्ज अंतिम कमांड का लिंक लिखता है। यह botCommands सूची से कमांड के लिंक को भी हटा देता है।
2. RemoveLastTextLine से RemoveLastTextLine विधि टर्मिनल UI से पाठ की अंतिम पंक्ति को हटा देती है ताकि UI botCommands की सामग्री से मेल botCommands ।
3. यदि undoStack स्टैक खाली है, तो RedoCommandEntry कुछ नहीं करता है। अन्यथा, यह undoStack के शीर्ष से अंतिम कमांड को undoStack और botCommands का उपयोग करके इसे वापस botCommands सूची में AddToCommands ।

अब हम इन कार्यों का उपयोग करने के लिए कीबोर्ड इनपुट जोड़ेंगे। SceneManager वर्ग के अंदर SceneManager Update विधि के शरीर को निम्न कोड से बदलें:

  if (Input.GetKeyDown(KeyCode.Return)) { ExecuteCommands(); } else if (Input.GetKeyDown(KeyCode.U)) //1 { UndoCommandEntry(); } else if (Input.GetKeyDown(KeyCode.R)) //2 { RedoCommandEntry(); } else { CheckForBotCommands(); } 

1. जब आप U कुंजी दबाते हैं, तो UndoCommandEntry विधि UndoCommandEntry ।
2. जब आप R कुंजी दबाते हैं, तो RedoCommandEntry विधि RedoCommandEntry ।

एज केस हैंडलिंग

महान, हम लगभग हो चुके हैं! लेकिन पहले, हमें निम्नलिखित करने की आवश्यकता है:

1. एक नया कमांड दर्ज करते समय, undoStack स्टैक को साफ किया जाना चाहिए।
2. कमांड निष्पादित करने से पहले, undoStack स्टैक को साफ़ करना होगा।

इसे लागू करने के लिए, हमें सबसे पहले SceneManager को एक नया तरीका SceneManager । CheckForBotCommands बाद निम्न विधि डालें:

  private void AddNewCommand(BotCommand botCommand) { undoStack.Clear(); AddToCommands(botCommand); } 

यह विधि undoStack साफ़ undoStack और फिर AddToCommands विधि को कॉल करती है।

अब कॉल को AddToCommands अंदर CheckForBotCommands साथ निम्नलिखित कोड से AddToCommands :

  AddNewCommand(botCommand); 

undoStack आदेश निष्पादित करने से पहले स्पष्ट करने के लिए ExecuteCommands विधि के अंदर if बाद निम्न पंक्ति सम्मिलित करें:

  undoStack.Clear(); 

और हम अंत में कर रहे हैं!

अपना काम बचाओ। प्रोजेक्ट बनाएं और Play Editor में क्लिक करें। पहले की तरह कमांड दर्ज करें। आदेशों को रद्द करने के लिए U दबाएं। रद्द किए गए आदेशों को दोहराने के लिए R दबाएं।


हरे रंग की चौकी में जाने की कोशिश करें।

आगे कहाँ जाना है?

गेम प्रोग्रामिंग में उपयोग किए जाने वाले डिज़ाइन पैटर्न के बारे में अधिक जानने के लिए, मैं सुझाव देता हूं कि आप रॉबर्ट निस्ट्रॉम के गेम प्रोग्रामिंग पैटर्न का अध्ययन करें।

उन्नत C # तकनीकों के बारे में अधिक जानने के लिए, C # संग्रह, Lambdas और LINQ पाठ्यक्रम लें।

कार्य

एक कार्य के रूप में, भूलभुलैया के अंत में हरित नियंत्रण बिंदु पर जाने का प्रयास करें। मैंने स्पॉइलर के नीचे एक समाधान छिपा दिया।