हम 2000 इकाइयों (XNA) तक जाते हैं

नमस्ते, इस पोस्ट में एक छोटा कोड प्रस्तुत किया जाएगा, कुछ तस्वीरों और कुछ वीडियो के बारे में कि कैसे मैंने XNA (2000 - 3000 इकाइयों) पर रॉकेट और इकाइयों की बातचीत के लिए एक तेज़ एल्गोरिथम लागू किया और न केवल।




पीएम में त्रुटियों के बारे में लिखें

यह सब कैसे शुरू हुआ

खेल शुरू करते समय, इकाइयों के साथ गोले की बातचीत के बारे में सवाल उठता है। पहले तो मैंने सोचा - "ठीक है, अब चक्र के साथ स्थितियों के लिए कुछ मिनट लगेंगे और सब कुछ चॉकलेट में होगा।"

यहाँ पहले जो मन में था:

foreach (var rocket in rockets) { foreach (var unit in units) { if (Contact(rocket, unit)) //      { unit.HP -= rocket.damage; //      } } } 

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

समस्या

यह जल्दी से काम किया जब तक कि मैंने एक एआई सिस्टम पेश नहीं किया जो कई जहाजों को नियंत्रित करता था। पहले वहाँ 6 इकाइयाँ (साथ ही मेरा जहाज) और दो दल थे। सब कुछ सही था, लेकिन जाहिर है कि पर्याप्त ड्राइव नहीं थी। और मैंने एक पंक्ति बदल दी है गिनना = 6; काउंटबोट पर = 100; और फिर लैग शुरू हो गए (21 एफपीएस), सबसे पहले मैं एक नुकसान में था और वास्तव में समझ नहीं पा रहा था कि कहां अनुकूलन करना है।

इसलिए, मुझे खेल का पहला संस्करण मिला, जहां 6 और इकाइयाँ हैं।

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

खैर, अब खोज और समस्या के समाधान पर वापस लौटें।
पुराने, दयालु विद्युत टेप डिजाइन ने लैग्स की खोज में मदद की:

 DateTime start = DateTime.Now; //     // ...     TimeSpan finish = DateTime.Now - start; //    Write(finish); //        

यह डिज़ाइन कोड के निष्पादन समय को मापता है, जो आपको ब्रेकिंग की जगह खोजने की अनुमति देता है। लगता है कि इस तरह की जगहों को ढूंढना हमेशा आसान होता है? लेकिन नहीं। मेरा मामला, बेशक, सरल है, लेकिन अधिक गंभीर क्षण थे।

आउटपुट कुछ इस तरह से देखा गया (100 इकाइयों के साथ):

जैसा कि आप देख सकते हैं, इस विधि को संसाधित करने में 41 एमएस लगे। जो लगभग 23-24 एफपीएस है

तो समस्या को खोजने में एक मिनट का समय लगा, आपने अनुमान लगाया, यह उन लाइनों में था जो टकराव की समस्या को हल करने के लिए प्रस्तावित थे। तो समस्या क्या थी? और यह था कि दो नेस्टेड छोरों का उपयोग किया गया था। ठीक है, 100 इकाइयों की कल्पना करें, प्रत्येक अग्नि 13 मिसाइलें प्रति सेकंड, जो लगभग 1300 मिसाइलें प्रति सेकंड के बराबर होती हैं (यहाँ, निश्चित रूप से, मैंने ठुकरा दिया, क्योंकि मैंने एक ही समय में सभी इकाइयों को शूट नहीं किया था, लेकिन फिर भी)। 1300 मिसाइलों को सैकड़ों जहाजों या 1300 * 100 = 130 हजार चेक प्रति सेकंड के साथ जांचने की आवश्यकता है।

और मुझे 2000, यहां तक ​​कि 3000 इकाइयों से एक खेल चाहिए था। वहाँ था और इस तरह के एक खेल " Cossacks: वार अगेन " है, इसमें 9999 से अधिक इकाइयां, विभिन्न प्रकार, भौतिकी और अन्य फिट के साथ बातचीत करते हैं। और चूंकि ऐसा खेल था (जैसे कि यह 10,000 इकाइयों तक आसानी से फिट हो सकता है), इसका मतलब है कि एक रास्ता है।

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

विचार

विचार का सार मानचित्र को 12 बड़े सत्यापन क्षेत्रों (आंकड़े में नीली रेखाओं के साथ चिह्नित) में विभाजित करना था, फिर इन ज़ोन द्वारा इकाइयों को सॉर्ट करना और इन ज़ोन के अंदर ही जांच करना आवश्यक था। तुम्हें पता है, यह काम किया, गति कई बार बढ़ी - यह मुझे बहुत खुशी हुई। अच्छा, तो फिर, प्रयोग क्यों नहीं? मैंने खुद जोनों को कम किया, जिससे उनकी संख्या बढ़ गई, अब 48 थे (आंकड़े में गुलाबी रेखाएं)। गति और भी अधिक बढ़ गई, फिर यह सिर्फ दिलचस्प था कि किस क्षेत्र में उत्पादकता बढ़ाने की संख्या मरना शुरू हो जाएगी (यह क्षण था, लेकिन मुझे याद नहीं है कि तब कितने जोन थे)।

परिणाम

इसके साथ खेलने के बाद, मैंने इस तथ्य को पकड़ लिया कि एक जहाज के आकार के साथ दो-आयामी सरणी कोशिकाओं को प्राप्त करना आसान है। इसके बाद, इस चरण को हर चरण में अपडेट करें, टकरावों की जांच करने के लिए, हमें रॉकेट के निर्देशांक लेने थे और उन्हें जहाज के आकार से विभाजित करना था, जिसने हमें दो आयामी सरणी के जहाजों में प्रक्षेप्य के स्थान के निर्देशांक दिए। खैर, और फिर सबसे सरल बात एक जहाज की उपस्थिति के लिए सरणी सेल की तुलना करना है।

यह मेरे कोड में कैसा दिखता है:

 public int gridWidth = (int)(Ship.Size.X); //     public int gridHeight = (int)(Ship.Size.Y); public List<Ship>[,] grid; //     (   ) //   public void UpdateGrid() { grid = new List<Ship>[map.border.Width / gridWidth, map.border.Height / gridHeight]; // map.border -    foreach (var ship in ships) { if (ship.isDead) //      continue; int x = (int)(ship.position.X / gridWidth); //     int y = (int)(ship.position.Y / gridHeight); if (x < 0) //   ,        x = 0; if (y < 0) y = 0; if (x + 1 > grid.GetLength(0)) x = grid.GetLength(0) - 1; if (y + 1 > grid.GetLength(1)) y = grid.GetLength(1) - 1; if (grid[x, y] == null) //      (  ) grid[x, y] = new List<Ship>(); grid[x, y].Add(ship); //           } } //    public void RocketContact() { // foreach    ,   -      for (int i = 0; i < rockets.Count; i++) { int x = (int)(rockets[i].position.X / gridWidth); //      int y = (int)(rockets[i].position.Y / gridHeight); if (x < 0) //       x = 0; if (y < 0) y = 0; if (x + 1 > grid.GetLength(0)) x = grid.GetLength(0) - 1; if (y + 1 > grid.GetLength(1)) y = grid.GetLength(1) - 1; if (grid[x, y] != null) //      ,    { Ship ship = grid[x, y][0]; //     -        if (!ship.isDead) //    ,      =) { if (ship.teamID != rockets[i].teamID) //      { ship.HP -= rockets[i].damage; if (rockets[i].hostPlayer != null) //       { rockets[i].hostPlayer.rocketHit++; //  -   if (ship.isDead) //   { rockets[i].hostPlayer.AddKill(); //   } } if (ship.isDead && ship.hostPlayer != null) // ,   ,     ship.hostPlayer.AddDead(); rockets.RemoveAt(i); //     (    ) i--; } } } } 

अब कोड की समीक्षा के दौरान सवाल उठ सकते हैं।

• हमें जहाज सूचियों के दो-आयामी सरणी की आवश्यकता क्यों है? मेरे खेल में, एक जहाज दूसरे जहाज के साथ निकटता से उड़ सकता है, और हमारे पास केवल एक शेल है, जिसका अर्थ है कि आप केवल एक जहाज को मार सकते हैं। मैं समझता हूं कि इस तरह से कुछ लिखना अधिक उचित होगा: जहाज जहाज = ग्रिड [x, y] [रैंडम.नेक्स्ट (ग्रिड [x, y] .Count)]; लेकिन पोस्ट उस बारे में नहीं है।
• प्रदर्शन के बारे में क्या? उत्पादकता बिल्कुल सौ गुना बढ़ गई है। अब 1.3 मिलियन चेक नहीं थे, लेकिन केवल 13 हजार थे।
• एक बैसाखी क्यों? क्योंकि यह मेरा पुराना कोड है, नया कोड थोड़ा अलग है। वहाँ, अगर, कोई ऑब्जेक्ट सरणी के बाहर है, तो यह केवल गलत नहीं करता है।
• इस डिज़ाइन पर कितनी RAM खर्च की गई है? यह मानचित्र के आकार और मेरे पास कितनी वस्तुओं पर निर्भर करता है, मानचित्र 10000x10000 पिक्स है, ग्रिड आकार 100x100 पिक्स है 2000 इकाइयों के साथ - लगभग 2 - 10 एमबी। स्मृति। यदि आपके पास अभी भी प्रश्न हैं, तो टिप्पणियों में पूछें (आपके समर्पित सीईपी)।

तुलना

पहले: 225 जहाजों को समायोजित करने की क्षमता में दुख और समय की हानि के लिए पुराने डिजाइन का अनुकूलन करने का प्रयास।

यदि आप ध्यान दें - कर्सर आसान और अधिक जानकारीपूर्ण हो गया है, हालांकि यह मुझे भी प्रभावित करता है।

के बाद: अनुकूलन इतना सफल था कि मैं 2000 इकाइयों तक जगह बना सका। वीडियो थोड़ा सूक्ष्म है (पिछले वाले की तरह) सिर्फ इसलिए कि कार्यक्रम का उपयोग स्क्रीन पर कब्जा करने के लिए किया गया था।

नवीनतम संस्करण में, संगीत दिखाई दिया (खेल में ही - यह वीडियो पर खेलता है), एक चलती पृष्ठभूमि, जिसके कारण अभिविन्यास समस्या आंशिक रूप से हल हो गई है।

अंत

मैंने सभी बनावटों को खुद चित्रित किया, दुर्भाग्य से मैं बेहतर बनाने के लिए कलाकार नहीं हूं। ऐसा इसलिए है क्योंकि मेरे पास इस तरह के साधारण खिलौनों के लिए पर्याप्त 2 डी कलाकार नहीं है।

टीडीएस विज़ 0.21 - जब मैं इसे पूरा करता हूं (यदि मैं इसे समाप्त करता हूं), तो मैं गिटहब पर परियोजना प्रकाशित करूंगा। यदि दिलचस्प क्षण हैं, तो उनके बारे में पोस्ट निश्चित रूप से दिखाई देंगे।

यदि दिलचस्पी है, तो मैं शुरू से अंत तक खेल के पूर्ण विकास के बारे में लिख सकता हूं।

खेल का पहला बीटा संस्करण (ज्यादा जज न करें)

पुनश्च एक बार फिर, पीएम की गलतियों और गलतियों के बारे में लिखें।
P.S2 वीडियो के गाने:
पछतावा कोड - पारगमन
केटी मेलुआ - बाढ़ (जैकवॉब रीमिक्स)
एरिक ब्रोसियस के एक युगल ट्राइब्स के गाने