चरित्र स्थितियों के साथ काम करें। एकता प्रयोग

एकता पर एक गेम विकसित करते समय, मुझे एक दिलचस्प काम मिला: एक चरित्र पर नकारात्मक या सकारात्मक प्रभावों की कार्रवाई का एक एक्स्टेंसिबल समय कैसे बनाया जाए।

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

इस पंक्ति के पहले संस्करणों में सभी स्थितियों के काले आइकन शामिल थे और जब प्रभाव हुआ, तो वांछित प्रकाश ऊपर।



प्रत्येक स्थिति में कोरुटिन था, जिसने एक निश्चित समय के बाद प्रभाव को रद्द कर दिया था।
इस निर्णय में एक महत्वपूर्ण ऋण है। यदि, खेल में कुछ घटनाओं के परिणामस्वरूप, पिछले समान प्रभाव की अवधि की तुलना में कम समय के बाद चरित्र को एक ही प्रभाव लागू किया जाता है, तो घटनाओं के दो संस्करण हो सकते हैं।

1. काफी गलत: पहले के समानांतर एक दूसरा कोरुटिन लॉन्च किया गया है। जब पहला पूरा हो जाता है, तो यह अपने मूल मूल्यों पर लौटता है, अर्थात्, दूसरे कोरआउट के काम खत्म होने से पहले प्रभाव को हटा दिया जाता है।
   
   
   
2. यह भी गलत है, लेकिन कुछ मामलों में स्वीकार्य है: पहला कोरआउट रद्द करें और दूसरा चलाएं। इस मामले में, प्रभाव की अवधि तब तक पहले प्रभाव की अवधि के बराबर होगी जब तक कि कोरआउट को रद्द नहीं किया जाता है + दूसरे कोरआउट की अवधि।
   
   
   

मेरे कार्य के लिए दोनों विधियां अस्वीकार्य हैं, क्योंकि मुझे प्रभाव की अवधि बढ़ाने की आवश्यकता है, ताकि मुझे प्रत्येक प्रभाव की अवधि का योग प्राप्त हो, चाहे प्रभाव कितनी बार लागू हो।

यदि चरित्र स्पाइक्स पर कदम रखता है, तो उसका पैर सशर्त रूप से क्षतिग्रस्त हो गया है और वह उसी गति से आगे बढ़ना जारी नहीं रख सकता है। मान लीजिए कि गति 5 सेकंड कम हो जाती है। यदि 3 सेकंड के बाद चरित्र अन्य स्पाइक्स पर कदम रखता है, तो गति को 5 सेकंड से कम किया जाना चाहिए। यानी 3 सेकंड बीत चुके हैं, नई स्पाइक्स से 2 + 5 सेकंड बचे हैं। प्रभाव की अवधि दूसरे स्पाइक्स (कुल 10) में हमले के क्षण से 7 सेकंड तक होनी चाहिए।

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

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

Dictionary<string, float> statusTime = new Dictionary<string, float>(); 

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

इसके लिए मैंने तीन विधियाँ जोड़ीं।

AddStatus

शब्दकोश में वांछित स्थिति जोड़ें, यदि इस तरह की स्थिति पहले से ही शब्दकोश में मौजूद है, तो अवधि जोड़ें। यदि कोई स्थिति नहीं है, तो हम अंत समय की गणना करते हैं और इसे शब्दकोश में जोड़ते हैं।

 private void AddStatus(string status, float duration) { if (statusTime.ContainsKey(status)) { statusTime[status] += duration; } else { float endTime = Time.timeSinceLevelLoad + duration; statusTime.Add(status, endTime); } } 

RemoveStatus

हम शब्दकोश से स्थिति को हटाते हैं, मूल मूल्यों को पुनर्स्थापित करते हैं।

 private void RemoveStatus(string status) { statusTime.Remove(status); RestoreStats(status); } 

CheckStatus

यदि शब्दकोश में स्थितियां हैं, तो हम यह देखने के लिए जांच करते हैं कि क्या उनका समय समाप्त हो गया है।

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

 private void CheckStatuses() { if (statusTime.Count > 0) { float currTime = Time.timeSinceLevelLoad; List<string> statuses = new List<string>(statusTime.Keys);  foreach (string stat in statuses) { if (currTime > statusTime[stat]) { RemoveStatus(stat); } } } } 

प्लसस की, जाहिर है, यह प्रभाव की एक लंबी अवधि है। यानी समस्या हल हो गई।
लेकिन एक महत्वपूर्ण माइनस यहाँ मौजूद है। हर फ्रेम को अपडेट करने के लिए स्टेटस की जाँच की जाती है। मेरे खेल में अधिकतम 4 खिलाड़ी हैं, जिसका मतलब है कि इस पद्धति को समानांतर में हर फ्रेम को 4 बार निष्पादित किया जाएगा। 4 पात्रों के साथ, मुझे लगता है कि यह महत्वपूर्ण नहीं है, लेकिन मुझे यकीन है कि अधिक पात्रों के साथ, यह प्रदर्शन समस्याओं का कारण बन सकता है। यह भी ध्यान देने योग्य है कि शब्दकोश में तत्वों की उपस्थिति के लिए जाँच करके विधि सुरक्षित है, और एक खाली शब्दकोश के साथ, लोड को कम किया जाना चाहिए।

भविष्य के लिए आगे देखते हुए (जो अभी भी इस खेल के लिए पूरी तरह से धूमिल है), मैं ऑनलाइन मोड में इस निर्णय पर भी भरोसा करता हूं, क्योंकि खिलाड़ी की स्थिति की जांच केवल वर्तमान स्थानीय खिलाड़ी के लिए होगी, और सभी तात्कालिक खिलाड़ियों के लिए नहीं।