आयताकार निर्देशांक और हेक्सागोनल ग्रिड के बारे में

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

प्रस्तावना

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

विषय द्वारा

ग्रिड विवरण

आरंभ करने के लिए, हम आयताकार निर्देशांक के सापेक्ष एक षट्कोणीय कोशिका को उन्मुख करने के लिए दो तरीके से भेद करते हैं:

मैंने अक्षों को "एम", "एल" और "आर" को मुख्य, बाएं और दाएं से पत्र कहा। (शुरू में, यह सब कागज के एक टुकड़े पर किया गया था, जहाँ एम एक्स अक्ष के साथ मेल खाता था, और वाई अक्ष ऊपर देखा - इसलिए, "बाएं" और "दाएं" यहां बहुत मनमाना हैं।) इस प्रकार, एम अक्ष आयताकार कुल्हाड़ियों में से एक से मेल खाता है; l अक्ष को इस आयताकार अक्ष के बारे में 60 डिग्री और दूसरे आयताकार अक्ष के बारे में 30 डिग्री घुमाया जाता है; आर अक्ष पहले आयताकार अक्ष के साथ 60 डिग्री और दूसरे के साथ 150 डिग्री है। कोशिकाओं की संख्या कुल्हाड़ियों m और l के साथ जाती है।

ग्रिड को लागू करने के लिए, मैंने एक "फील्ड मैनेजर" लिखा - एक ऐसा वर्ग जिसका ऑब्जेक्ट ग्रिड के अभिविन्यास और अवधि के बारे में जानकारी संग्रहीत करता है।

//      Qt- , , // ..      ,  //  typedef-. typedef QPointF MyPointF; typedef QPoint MyPointI; //    class FieldManager { public: //  ,     m. enum Orientation { OX, OY }; //   . FieldManager(double period = 1, Orientation orientation = OX); //       ( ). MyPointF CellCenter(int m, int l) const; //   ,     (x, y) ( ). MyPointI CellInd(double x, double y) const; private: //  . double m_period; //  . Orientation m_orientation; }; 

प्रत्यक्ष रूपांतरण

 //    ,  //     . const double sin60 = sqrt(3.0) * 0.5; const double cos60 = 0.5; const double sin30 = cos60; const double cos30 = sin60; //  . FieldManager::FieldManager(double period, Orientation orientation) : m_period(period), m_orientation(orientation) { } //  .   . MyPointF FieldManager::CellCenter(int m, int l) const { double along_coord = m_period * (m + l * cos60); double other_coord = m_period * l * sin60; if (m_orientation == OX) return MyPointF(along_coord, other_coord); else return MyPointF(other_coord, along_coord); } 

उलटा परिवर्तन

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

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

 //  . MyPointI FieldManager::CellInd(double x, double y) const { //   . double along_coord = (m_orientation == OX) ? x : y; double other_coord = (m_orientation == OX) ? y : x; //     m, l  r (   ). //       , // , ,         //    int m = floor(2 * along_coord / m_period); int l = floor(2 * (cos60 * along_coord + sin60 * other_coord) / m_period); int r = floor(2 * (cos60 * along_coord - sin60 * other_coord) / m_period); // , ,   : return MyPointI( floor((m + r + 2) / 3.0), floor((l - r + 1) / 3.0)); } 

इस परिवर्तन को खोजने के लिए, निम्नलिखित क्रियाओं ने मेरी मदद की: मैंने कागज के एक टुकड़े पर इन त्रिभुजों की एक ग्रिड को खींचा, फिर उस पर षट्भुज की "लाइनों" को लगातार मान के साथ (खाते में गोलाई में लेते हुए) चुना और देखा कि परिणामी त्रिकोण को जोड़ती है। फिर उन्होंने एल अक्ष के लिए भी ऐसा ही किया। यह स्पष्ट था कि l अक्ष के साथ निर्देशित हेक्सागोन्स की एक पट्टी के लिए, m और r axes अंतरिक्ष को rhombuses में विभाजित करते हैं जो इस पट्टी को नहीं काटते हैं (यानी, इसके अंदर या बाहर पूरी तरह से झूठ बोलना)। इसके अलावा, एक निश्चित मीटर के साथ, यह बैंड अलग-अलग एल और इसके विपरीत तीन rhombuses से मेल खाता है। यह वह जगह है जहाँ 3 से भाग देने से चक्कर आते हैं। इसी तरह दूसरे बैंड के लिए।

निष्कर्ष

इस नोट पर, यह कथा समाप्त होती है। मैं उन सभी को धन्यवाद देता हूं जिन्होंने ध्यान से वंचित नहीं किया। मुझे उम्मीद है कि मैं किसी की मदद कर सकता हूं।

पुनश्च
मुझे यह भी उम्मीद है कि खेल किसी दिन प्रकाश को देखेगा और इसके बारे में एक लेख भी यहां दिखाई देगा।