एक bejeweled की तरह खेल के पीछे तर्क

Question

एक प्रोटोटाइप में मैं कर रहा हूँ, bejeweled के समान एक मिनीगेम है। एक ग्रिड का उपयोग करना जो एक 2d सरणी है ( int[,]) मैं कैसे जान सकता हूं कि उपयोगकर्ता ने एक मैच कब बनाया? मुझे केवल क्षैतिज और लंबवत के बारे में परवाह है।

मेरे सिर के ऊपर से मैं सोच रहा था कि मैं प्रत्येक दिशा देखूंगा। कुछ इस तरह:

int item = grid[x,y];
if(grid[x-1,y]==item)
{
    int step=x;
    int matches =2;
    while(grid[step-1,y]==item)
    {
        step++;
        matches++
    }
    if(matches>2)
        //remove all matching items
}
else if(grid[x+1,y]==item
    //....
else if(grid[x,y-1==item)
    //...
else if(grid[x,y+1]==item)
    //...

ऐसा लगता है कि एक बेहतर तरीका होना चाहिए। है?

Comments

मुझे याद है मैंने ऐसा करने के लिए लूप के लिए थकाऊ लिखा था (कनेक्ट-एन के लिए)

— मिंग-तांग

Answer 1

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

AS3 कोड:

var grid:Array = [[2,3,2,2,2,4],
                  [ .. ]]; //multidimensional array
var matches:uint;
var gemType:uint;
for(col = 0; col < grid.length; col++){
    matches = 0;        
    gemType = 0; //Reserve 0 for the empty state. If we make it a normal gem type, then only 2 are needed to match for the start.
    for(i = 0; i < grid[0].length; i++){
        if(grid[col][i] == gemType){
            matches++;
        }
        if(grid[col][i] != gemType || i == grid[0].length - 1){ //subtract 1 because arrays start at 0
            if(matches >= 3){
                removeMatches(blah);
            }
            gemType = grid[col][i];
            matches = 1;
        }
    }
}

यह केवल x अक्ष के लिए y, ग्रिड [col] [i] के लिए ग्रिड [i] [पंक्ति], इत्यादि के लिए है, मुझे यकीन है कि आप यह पता लगा सकते हैं :)

Answer 2

बस मैंने सोचा था कि मैं मैच -3 जैसे खेल के निर्माण में अपने अनुभव के साथ तौलना चाहूंगा।

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

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

Comments

आपका उत्तर एक उत्तर होना चाहिए और दूसरा प्रश्न नहीं जोड़ना चाहिए। यदि आपके पास कोई प्रश्न है, तो कृपया "ASK QUESTION" बटन का उपयोग करके एक नया प्रश्न बनाएं। यह कोई चर्चा मंच नहीं है।

— बंमज़ैक

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

— विसम

कोई बात नहीं। लेकिन आपको अपने उत्तर से "प्रश्न" वाले हिस्से को हटा देना चाहिए। प्रश्न नए प्रश्न होने चाहिए और उत्तर का हिस्सा नहीं होना चाहिए ...

— bummzack

संपादित और प्रश्न को कहीं और पोस्ट किया

— विस्म

Answer 3

पुनरावृत्ति, यो। यह तब होता है जब आप अपनी सीमाओं को नहीं जानते हैं।

   public int getHMatchSize(int row, int column)
    {
        int returnMe = getMatchValue(row, 0, column, 1);

        if (returnMe < 3)
        {
            return 0;
        }
        else return returnMe;
    }


    public int getVMatchSize(int row, int column)
    {
        int returnMe = getMatchValue(row, 1, column, 0);

        if (returnMe < 3)
        {
            return 0;
        }
        else return returnMe;
    }

    /// <summary>
    /// I return the match size.
    /// </summary>
    /// <param name="row"></param>
    /// <param name="rowDelta">1 means look vertically.  Dont set both deltas to 1.</param>
    /// <param name="column"></param>
    /// <param name="columnDelta">1 means look horizontally.  Dont set both deltas to 1.</param>
    /// <returns>The number of contiguous matching things</returns>
    public int getMatchValue(int row, int rowDelta, int column, int columnDelta)
    {
        int[] start = getEndItem(row, -1 * rowDelta, column, -1 * columnDelta);
        int[] end = getEndItem(row, rowDelta, column, columnDelta);

        int returnMe = 0;
        returnMe += end[0] - start[0];
        returnMe += end[1] - start[1];
        return returnMe;
    }

    /// <summary>
    /// I will return the end of a sequence of matching items.
    /// </summary>
    /// <param name="row">start here</param>
    /// <param name="column">start here</param>
    private int[] getEndItem(int row, int rowDelta, int column, int columnDelta)
    {
        Gem matchGem = new Gem(-1);
        int[] returnMe = new int[2];

        if (boardSpace[row + rowDelta][column + columnDelta] == boardSpace[row][column])
        {
            return getEndItem(row + rowDelta, rowDelta, column + columnDelta, columnDelta);
        }
        else
        {
            returnMe[0] = row;
            returnMe[1] = column;
            return returnMe;
        }
    }

Answer 4

आप बाढ़ भराव एल्गोरिथ्म का उपयोग कर सकते हैं । यह इस प्रकार की समस्या के लिए वास्तव में प्रयोग करने योग्य है।

Comments

नहीं, वास्तव में इसका प्रश्न से कोई लेना-देना नहीं है। ओपी पूछ रहा है कि एक पंक्ति में तीन मिलान वस्तुओं का पता कैसे लगाया जाए।

— साइक्लोप्स

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

— ktornai

आपको शायद "बाढ़ भराव का उपयोग करें" की तुलना में थोड़ा अधिक व्याख्या करनी चाहिए क्योंकि मैं एक दूसरे के लिए उलझन में था कि यह समस्या कैसे प्रासंगिक है।

— 12 झॉकिंग