3 की अधिकतम बहुलता के साथ मूल से किनारों और शीर्षों को उत्पन्न करने के लिए एल्गोरिदम


11

मैं एक वेबसाइट के लिए 2 डी गेम बना रहा हूं, जहां ब्रह्मांड बहुत बड़ा हो सकता है (मूल रूप से असीम रूप से बड़ा)। प्रारंभ में, ब्रह्मांड 6 सितारों से बना है जो मूल (0, 0) से एक समान दूरी पर हैं। मेरा कार्य अधिक सितारों को उत्पन्न करने में सक्षम होना है जिनके पास "पथ" (किनारे) होंगे जो एक दूसरे से जुड़ते हैं। मैं एक एल्गोरिथ्म कैसे डिजाइन कर सकता हूं जो इन प्रतिबंधों को पूरा करता है:

  1. सितारे बेतरतीब ढंग से बाहर की ओर उत्पन्न होते हैं। (जैसे (x, y) नए सितारों के लिए निर्देशांक धीरे-धीरे सभी दिशाओं में (0, 0) से बाहर की ओर जाएंगे, अधिमानतः सर्पिल प्रारूप में)
  2. किनारों को पार नहीं किया जाएगा।
  3. हालांकि कुछ विचरण होना चाहिए, नए सितारों को बहुत दूर या अन्य सितारों के बहुत करीब नहीं होना चाहिए। (उदाहरण के लिए न्यूनतम त्रिज्या होनी चाहिए)
  4. किसी भी स्टार / पॉइंट में 3 से अधिक की बहुलता नहीं होनी चाहिए।
  5. यह देखते हुए कि यह सब एक डेटाबेस में संग्रहीत किया जाएगा, एल्गोरिथ्म बहुत महंगा नहीं हो सकता है। दूसरे शब्दों में, मैं ओ (एन) जटिलता के कुछ हासिल करना पसंद करूंगा (मुझे नहीं पता कि यह संभव है)।

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

मुझे जिन विशेष चरणों को हल करने की आवश्यकता है वे हैं:

  1. अन्य सितारों के पड़ोसी आसपास के क्षेत्र में बेतरतीब ढंग से एक बिंदु उत्पन्न करते हैं जो अभी तक 3 की बहुलता नहीं है।
  2. पहला तारा खोजें जिसमें अभी तक 3 की बहुलता नहीं है जो किनारे के संघर्ष को उत्पन्न नहीं करेगा।
  3. यदि तारा x इकाइयों की न्यूनतम दूरी है तो दो बिंदुओं के बीच एक बढ़त बनाएं।

मैंने समाधान खोजने की कोशिश की, लेकिन मेरे गणित कौशल (और ग्राफ थ्योरी पर ज्ञान) को बहुत काम करने की आवश्यकता है। इसके अलावा, इस मामले पर किसी भी संसाधन / लिंक की बहुत सराहना की जाएगी।

यहाँ कुछ छद्म कोड है जिसके बारे में मैं सोच रहा था, लेकिन मुझे यकीन नहीं है कि यह काम करेगा और मुझे यकीन है कि यह कुछ 10,000, आदि सितारों के बाद बहुत अच्छा प्रदर्शन नहीं करेगा।

newStar = randomly generated (x, y) within radius of last star from origin
while(newStar has not been connected):
    for (star in the known universe):
        if(distance between newStar and star > x units):
            if(star has < 3 multiplicity):
                if(path from newStar to star does not intersect another path):
                    connect the star to the other star
                    break;

    newStar = new random (x, y) coordinate

इसके अलावा, अगर किसी को इस बारे में कोई सलाह है कि मुझे इसे MySQL डेटाबेस पर कैसे संग्रहीत करना चाहिए, तो मैं भी इसकी सराहना करूंगा।

अंत में, अगर ऊपर कुछ भी समझ में नहीं आता है, तो मैंने एक छवि शामिल की है जिसे मैं नीचे हासिल करना चाहूंगा:और आदि, सितारों का एक बहुत ...


1
इस ब्रह्मांड का एक यात्री एक दिशा में जाने की संभावना है, यदि आप तारों से बाहर निकलते हैं, तो आपको मूल से सभी दिशाओं में तारों को उत्पन्न करना होगा। एक ऊब उपयोगकर्ता आपके डेटाबेस को दूसरे शब्दों में तोड़ सकता है। क्या आपने इस संभावना पर विचार किया है (यह मानते हुए कि यह एक मुद्दा हो सकता है)?
नील

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

1
यदि प्रत्येक उत्पन्न तारे में 3 की बहुलता है, तो चरण 1 विफल हो जाएगा तो आप क्या करेंगे? कोई भी आपकी तस्वीर में 4 के गुणन के साथ एक बिंदु क्यों है, क्या यह एक त्रुटि है?
डॉक्टर ब्राउन

1
नहीं। यदि आप अनुमान लगाने योग्य तरीके से तारों को उत्पन्न कर सकते हैं, तो यह वैसा ही होगा जैसे वे हमेशा वहाँ रहे थे यदि आप छोड़ दें और फिर वापस लौट आएं। यह केवल एल्गोरिथ्म और बीज है जो बदलते नहीं हैं।
नील

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

जवाबों:


2

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

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

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

यह कैसे करें: फ्रैक्चर इलाके जनरेटर देखें। इसके लिए बहुत सारे मुफ्त और खुले कोड हैं। आपको केवल मूल कोड की आवश्यकता होती है जो मानचित्र पर प्रत्येक बिंदु के लिए ऊंचाई मान उत्पन्न करता है। हम इसे एक अलग तरीके से उपयोग करने जा रहे हैं। TWO स्वतंत्र भू-ऊंचाई मानचित्र बनाने के लिए उस कोड का उपयोग करें। स्टार के असली X, Y स्थिति के साथ शुरू करें, प्रत्येक मानचित्र पर उस स्थान को देखें, स्टार के X डिस्प्ले स्थिति को ऑफसेट करने के लिए एक मैप मान का उपयोग करें और स्टार के Y डिस्प्ले की स्थिति को ऑफसेट करने के लिए अन्य मैप मान का उपयोग करें। आपको स्केलिंग कारकों में से कुछ के साथ खेलना होगा, लेकिन यह आपको बेतरतीब ढंग से विकृत रबड़ शीट प्रभाव दे सकता है। स्टार की स्थिति में बड़े बदलाव अंतर्निहित आदेशों को पूरी तरह से छिपाना चाहिए। बेतरतीब प्रकृति की भयावह प्रकृति एक बहुत ही प्राकृतिक प्रभाव देगी,

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.