हेक्स ग्रिड को समान रूप से एन खिलाड़ियों में कैसे विभाजित करें?


15

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

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


: सेलुलर ऑटोमेटा एक सरल तरीका है, इस के समान है एक साधारण नक्शा, चार बायोम, और उन्हें कैसे वितरित करने के लिए
MichaelHouse

जवाबों:


3

क्या यही मुझे करना होगा:

  1. यादृच्छिक खिलाड़ियों को सभी कोशिकाओं को असाइन करें। बड़े मानचित्रों पर यह सभी खिलाड़ियों के लिए बहुत अधिक संख्या में टाइलों का उत्पादन करने की संभावना है, छोटे मानचित्रों पर आपको शायद कुछ सुधार करने की आवश्यकता होगी।
  2. बहुत बड़े हैं कि टूटना। सबसे आसान काम यह होगा कि सभी टाइलों को चूजों में ले लिया जाए और फिर से प्रत्येक टाइल को यादृच्छिक रूप से असाइन किया जाए।
  3. कोशिकाओं की असंतुलित संख्या के मामले में (जैसे खिलाड़ी A में 24 सेल हैं, खिलाड़ी B के पास 16 हैं), ओवररप्रेट किए गए खिलाड़ियों से लेकर अंडररप्रेट किए गए खिलाड़ियों तक कोशिकाओं के एक जोड़े को पुन: असाइन करें।
  4. विखंडू के लिए फिर से जाँच करें। यदि चरण 3 ने नए विखंडू पेश किए, तो चरण 2 पर वापस जाएं। यदि नहीं, तो अच्छा नक्शा!

पुनश्च मुझे नहीं लगता कि यह समस्या कभी असंभव है, मानचित्र रंग की समस्या काफी अलग है (एक चीज़ के लिए यह दूसरा तरीका है, आकार-> रंगों के बजाय रंग-> टाइल असाइनमेंट)।
जुनेक्स

मुझे यह दृष्टिकोण काफी पसंद है, लेकिन क्या इसके लिए लंबे समय तक चलने की संभावना नहीं है, क्षेत्र के आकार को संतुलित करने की कोशिश कर रहा है?
7 से

1
@manabreak: मैंने इसे आज़माने के लिए कुछ बनाया है । चरण 2 में एक छोटे से परिवर्तन के साथ (पुन: असाइन करने के बजाय सभी खिलाड़ियों के माध्यम से साइकिल द्वारा पुन: असाइन करना) यादृच्छिक रूप से काम करता है। मैं इसे लिखने की कोशिश करूंगा जब मेरे पास समय होगा।
Junuxx

1
वह वही दिखता है, जिसकी मुझे तलाश थी। :)
मनब्रीक

1

मान लें कि आप का एक hexmap है nकुल में कोशिकाओं, और pखिलाड़ियों, जहां p <= n, सबसे अच्छा तरीका यह से निपटने के लिए करने के लिए के माध्यम से है राउंड-रोबिन वितरण के माध्यम से सेलुलर ऑटोमेटा (सीए)।

initialisation

बेतरतीब ढंग से (और / या कुछ या अन्य अनुमानी का उपयोग करके, जैसे मानचित्र केंद्र से दूरी) प्रत्येक खिलाड़ी के लिए एक प्रारंभिक सेल चुनें। चूंकि p <= n, यह एक समस्या नहीं होनी चाहिए।

सेल्यूलर आटोमेटा

आपको अपने हेक्स कोशिकाओं के बीच पूर्ण कनेक्टिविटी की आवश्यकता होती है। मैं प्रति सेल 6-पड़ोसी सरणी का सुझाव दूंगा:

class Cell
{
   //... other members...
   Cell[6] neighbours = new Cell[6];
}

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

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

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

गोल-रॉबिन वितरण

स्यूडोकोड:

count number of neutral cells in entire map, minus those starting cells taken by players
while neutral cells remain (or while true)
   for each player
      if player has not yet reached expected territory size in cells
         for each cell already constituting this player's territory
           if territory can grow by one cell into a neutral neighbour
              grow into neighbour
              reduce neutral cell count for entire map by one
              if no more neutral cells remain in map
                 break out of outermost while loop immediately
              else
                 continue to next player immediately
begin game

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

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


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

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

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

@ यदि आपका तर्क गलती पर है। अपने अंतिम वाक्य में, आप स्वीकार करते हैं कि मेरा एल्गोरिथ्म द्वीप के आकार पर रुकता है n, और उसके बाद खुद को यह कहते हुए प्रतिवाद करता है कि आप "अभी तक ऐसा नहीं करते हैं" कि मैं "उल्लेख कैसे करता हूं" बाद के पाठ में [द्वीपों को कैसे प्राप्त करें] "। क्या मैंने या मैंने इस सवाल का जवाब नहीं दिया है? इस सामान्यीकृत एल्गोरिथ्म का उपयोग या तो बिखरी हुई कोशिकाओं ( n1 तक सीमित करके ) या द्वीप बनाने के लिए (n> 1 सेट करके) किया जा सकता है। तो आपके पास एक एकल एल्गोरिथ्म में, न केवल बिखरने की क्षमता है, बल्कि समूह के लिए भी है। यह ओपी के सवाल का जवाब कैसे नहीं देता है ? कैसे यह एक पतन के योग्य है?
इंजीनियर

मैं अपनी टिप्पणी ऊपर संपादित करूंगा, लेकिन बहुत देर हो चुकी है। "मुझे आपके एल्गोरिथ्म में एक रास्ता नहीं दिख रहा है "। यद्यपि आप बाद के पाठ में अवधारणा का उल्लेख करते हैं।
fnord

0

एक अन्य दृष्टिकोण एक वितरण के साथ शुरू होगा जो 'उचित' है, लेकिन नियमित है, और फिर निष्पक्षता को खोने के बिना नियमितता को तोड़ने के लिए नकली एनालाइजिंग के समान एक एप्राच का उपयोग करें:

  • अपने ग्रिड की सभी कोशिकाओं को एक नियमित पैटर्न (जैसे, 123412341234) को पहली पंक्ति में दोहराएं, इसके बाद अगली पंक्ति में '341234123412' इत्यादि को रंग दें। इससे रंगों का गैर-समान वितरण हो सकता है यदि आपका नक्शा विशेष रूप से खराब आकार का है, लेकिन मैं मान रहा हूं कि आप एक निश्चित नक्शे के साथ शुरू कर रहे हैं, इसलिए आपको इसके समान नियमित रूप से कुछ समान रंग खोजने में सक्षम होना चाहिए ।
  • फिर निम्न चरणों का पालन करें जैसा कि आप महसूस करते हैं (कोई वास्तविक 'दान' मानदंड नहीं है, इसलिए प्रयोग आपको बताएगा कि चरणों की न्यूनतम उचित संख्या क्या है):
    • यादृच्छिक पर ग्रिड के दो तत्वों को चुनें
    • यदि उनके पास एक ही रंग है, तो फिर से प्रयास करें (कोई मतलब नहीं है अन्यथा, तब से स्वैपिंग एक नो-ऑप होगी। आपके पास एक ही रंग मारने का 1/4 मौका है, और एक ही रंग मारने का 1/16 मौका है। एक पंक्ति में दो बार, इसलिए आपको कभी भी बहुत अधिक प्रयास नहीं करना चाहिए)
    • अस्थायी रूप से उन दो तत्वों के रंगों को स्वैप करें
    • स्वैप के बाद तत्वों के स्थानों में नवगठित क्षेत्रों के आकार का परीक्षण करें:
      • प्रत्येक तत्व के नए स्थान से बाहर की ओर एक साधारण बाढ़-भरने के लिए यह निर्धारित करें कि स्वैप का कितना बड़ा क्षेत्र होगा।
    • यदि इन दोनों क्षेत्रों में से कोई भी आपकी सीमा से बड़ा है, तो अनंतिम स्वैप में; अन्यथा, दो तत्वों के रंग की 'अदला-बदली' को अंतिम रूप दें।

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

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


स्टोकेस्टिक दृष्टिकोण अक्षम हैं। मेरे जैसे एक दृष्टिकोण के लिए, जो चरणों पर विचार करता है, रनटाइम दृष्टिकोण के लिए ओ (एन) एन मानचित्र कोशिकाओं के लिए आता है। आपके एल्गोरिथ्म के लिए, यह O (n * m) है, जहाँ m प्रति द्वीप वांछित कोशिकाओं की संख्या है (वास्तव में, प्रत्येक संभावित द्वीप के लिए)। हमेशा उन एल्गोरिदम का लक्ष्य रखना सबसे अच्छा होता है जिनमें आसानी से अनुमान लगाने योग्य रनटाइम होता है। एक बेतरतीब ढंग से बनाए गए नक्शे को ठीक करने के बजाय, ऐसे नक्शे को उत्पन्न करने के लिए बेहतर है जो पहले चरण में टूटे या बेतरतीब न हों, एन चरणों में, इस प्रकार एक नियंत्रित, कुशल प्रक्रिया को बनाए रखना।
इंजीनियर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.