शब्द खेल - बोर्ड कार्यान्वयन?

Question

मैं libgdx का उपयोग करके Android के लिए एक दलदल प्रकार के खेल पर काम कर रहा हूं। उपयोगकर्ता को 4x4 अक्षरों के ग्रिड के साथ प्रस्तुत किया जाता है और उन्हें अक्षरों पर अपनी उंगली खींचकर शब्द ढूंढने चाहिए।

दलदल के विपरीत, मैं चाहता था कि पत्र गायब हो जाएं। शेष पत्र नीचे गिर जाएंगे (बोर्ड के नीचे, स्क्रीन ओरिएंटेशन तय हो गया है) और बोर्ड को ऊपर से रिफिल किया गया है। उपयोगकर्ता रणनीतिक शब्द चयन द्वारा बेहतर स्थान पर अक्षरों का उपयोग करने की कोशिश करने के लिए बोर्ड को घुमा सकते हैं।

एक उदाहरण:

d g a o
u o r T
h v R I
d G n a

यदि मैंने GRIT शब्द का चयन किया है, तो वे अक्षर गायब हो जाएंगे और शेष नीचे गिर जाएंगे:

d
u g a
h o r o
d v n a

और फिर नए अक्षरों से प्रतिस्थापित करें

d w x y
u g a z
h o r o
d v n a

मुझे पता है कि बोर्ड और टाइल्स का प्रतिनिधित्व कैसे करना है।

मैंने बोर्ड का प्रतिनिधित्व करने के लिए एक मैट्रिक्स के रूप में चयनित टाइलों और वैध चालों और एक मैट्रिक्स में संग्रहीत टाइलों का ट्रैक रखने की कोशिश की ताकि एक आसान मैपिंग हो। यह काम करता है, लेकिन मुझे बोर्ड को घुमाने के लिए कुछ जटिल कोड लिखना पड़ा।

अन्य खेल इस समस्या को कैसे संभालते हैं?

संपादित करें: तो इसके बारे में सोचकर, मुझे वास्तव में सिर्फ बोर्ड रोटेशन के अनुसार अपने स्पर्श बिंदु को संसाधित करना चाहिए ताकि कोशिकाएं स्थिर रहें। मैं क्या सोच रहा हूँ की एक छवि संलग्न।

Comments

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

— पेट्र अब्दुलिन

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

— andy mcevoy

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

— पेट्र अब्दुलिन

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

— andy mcevoy

कृपया इसे उत्तर में रखें और यदि आपने अपनी समस्या का हल खोज लिया है तो अपना उत्तर स्वीकार करें; यदि आप अभी भी 100% सुनिश्चित नहीं हैं तो आप इसे खुला रख सकते हैं। आपके प्रस्तावित समाधान का वर्णन करने के लिए शब्द "स्पेस ट्रांसलेशन" है, यानी आप स्क्रीन स्पेस और (घुमाए गए) बोर्ड स्पेस के बीच अपने स्पर्श बिंदु का अनुवाद कर रहे हैं।

— इंजीनियर

Answer 1

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

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

मैंने कॉनवे के गेम ऑफ लाइफ को लागू करने के लिए इस दृष्टिकोण का उपयोग किया है और एक बार जब आप इसे स्थापित कर लेते हैं, तो यह पड़ोसियों को आधारित एक नोड की स्थिति को बदलने वाले तर्क को जोड़ने की जटिलता को काफी कम कर देता है।

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

Answer 2

हाँ समाधान है कि आप अपने मैट्रिक्स या सरणी से मान प्राप्त करें और अस्थायी मान या मैट्रिक्स के लिए मान सेट करें और फिर वहाँ से मान सेट करें यह आपको अपना घुमा मूल्य दिखाएगा। मैंने नीचे कोड जोड़ा है मुझे लगता है कि इसकी मदद से आप

    int MAX_GRID = 4;
    int[][] main_array = new int[MAX_GRID][MAX_GRID];
    int[][] temp_array = new int[MAX_GRID][MAX_GRID];

    /** This method for clockwise **/
    int mainRow = MAX_GRID - 1;
    for (int c = 0; c < MAX_GRID; c++) {
        for (int r = 0; r < MAX_GRID; r++) {
            temp_array [mainRow][c] = main_array [r][c];
            Log.i("TAG", "R C : [ " + mainRow + " " + c + " ]" + " => [ "
                    + r + " " + c + " ]");
            mainRow--;
        }
    }
    main_array = temp_array;

    /** This method for anti-clockwise **/
    int mainCol = 0;
    for (int c = MAX_GRID - 1; c >= 0; c--) {
        for (int r = MAX_GRID - 1; r >= 0; r--) {
            temp_array [r][mainCol] = main_array [c][r];
            Log.i("TAG", "R C : [ " + r + " " + mainCol + " ]" + " => [ "
                    + c + " " + r + " ]");
        }
        mainCol++;
    }
    main_array = temp_array;

    // Now you can set main_array value then its rotate