खिलाड़ियों को एक साथ एक ही वर्ग में ले जाना?

Question

वर्गों के 2 x 2 ग्रिड पर विचार करें। एक खिलाड़ी एक वर्ग पर जा सकता है अगर:

• कोई भी अन्य खिलाड़ी अगली बारी में वर्ग में नहीं जाना चाहता
• किसी अन्य खिलाड़ी ने इंतजार नहीं किया है और अभी भी इस मोड़ पर वर्ग का कब्जा है

मैंने अपनी समस्या का वर्णन करने के लिए ऊपर दी गई छवि को शामिल किया है।

खिलाड़ी एक साथ चलते हैं।

यदि 2 (या अधिक) खिलाड़ी एक ही वर्ग में जाने की कोशिश करते हैं, तो न ही आगे बढ़ें।

Comments

क्या खिलाड़ी एक-एक चरण में एक-दूसरे से जुड़ सकते हैं? उदाहरण के लिए, पीले और नीले रंग के स्विच एक ही चरण में हो सकते हैं (नीला एक टाइल बाएं जाता है, और पीला एक टाइल दाईं ओर जाता है)?

— अली 1 एस 232

गजेट अभी के लिए हाँ। लेकिन कुछ बिंदु पर मैं 2 पड़ोसी खिलाड़ियों को सीधे स्वैप करने में सक्षम नहीं होना

— चाहूंगा

तब मेरा उत्तर उस मुद्दे को हल करता है।

— अली 1 एस 232 21

सटीक प्रासंगिक: कूटनीति के लिए आंदोलन के नियमों की जाँच करें। en.wikipedia.org/wiki/Diplomacy_(game)#Movement_phase

— TehShrike

Answer 1

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

मुझे लगता है कि काम करना चाहिए। यह निश्चित रूप से आपके द्वारा पोस्ट किए गए मामले के लिए काम करता है, और कुछ अन्य तुच्छ मामलों का मैंने इस पर परीक्षण किया।

Comments

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

— इल्मरी करोनें सिप

Answer 2

टकराव की रोकथाम के बजाय टकराव का संकल्प।

बस वस्तुओं को स्थानांतरित करें, फिर जांचें कि क्या कोई टक्कर हुई है। यदि किसी अन्य ब्लॉक के साथ पिछले वर्ग में वापस जाना है, या गेम के प्रकार पर निर्भर करता है, तो एक अलग वर्ग।

Comments

हां, लेकिन अगर किसी को वापस जाना है तो दूसरों को भी पीछे

— हटना होगा

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

— अल्टिफिनिटस 15

आपको एक चरण में सभी टकरावों को हल करने की आवश्यकता नहीं है। सभी ऑब्जेक्ट को स्थानांतरित करें, जांचें कि क्या कोई टक्कर उस टक्कर में संबंधित रिवर्स चाल है, इस प्रक्रिया को दोहराएं जब तक कि कोई टक्कर नहीं बची हो।

— अली 1 एस 232

Answer 3

Move all players according to their request.
while there are still some squares multiply occupied:
    For each square that is now multiply occupied:
        For each player in that square that moved there this turn:
            Return them to their previous square
            Mark them as having not moved this turn

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

Answer 4

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

Comments

मुझे लगता है कि यहां आपके मन में कुछ है, लेकिन यह आपके उत्तर में नहीं आ रहा है। 2x मानचित्र का उपयोग टकराव की समस्या को कैसे हल करता है?

— ज़ैन लिंक्स

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

— ज़ेन लिंक्स

@ZanLynx: ठीक यही है कि यह समस्या को हल करता है, एकमात्र समस्या तब होगी जब दो टुकड़े (हरा और नीला) टकराने जा रहे हों और दूसरा टुकड़ा (पीला) हरे रंग की अंतिम स्थिति को भरने वाला हो। इन के समान मामलों में (यदि वे संभव हैं) तो आपको टकरावों को हल करने की आवश्यकता है क्योंकि सुझाए गए अल्टिफिनिटस।

— अली 1 एस 232 1

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

— अली 1 एस 232 1

Answer 5

किसी सरणी या मानचित्र का उपयोग करके सभी अनुरोधित चालों को पंजीकृत करें।

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

छद्म कोड:

int[][] game; // game board

var doMoves() {
    int[][] dest = [][]; // destinations; cleared each run

    for (obj in gameObjects)
        if (obj.moveRequest) {
            var o = dest[obj.moveX][obj.moveY];
            if (o) {
                // collision!
                o.doNotMove = true;
                obj.doNotMove = true;
            } else {
                dest[obj.moveX][obj.moveY] = obj;
            }
        }
    }

    // check move validity
    for (obj in gameObjects) {
        if (obj.doNotMove) continue;

        var o = game[obj.moveX][obj.moveY];
        if (o and o.doNotMove)
            revertRequest(obj, dest);
    }

    // process moves
    //etc
}

// recursive function to back up chained moves
var revertRequest(obj, dest) {
    if (!obj.doNotMove) {
        obj.doNotMove = true;
        var next = dest[obj.x][obj.y];
        if (next)
            revertRequest(next, dest);
    }
}

Answer 6

शमौन के जवाब पर निर्माण , यहाँ एक स्पष्ट एल्गोरिथ्म है:

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

• यदि squares[S]है NULL, तो वर्ग Sमें जाने के लिए स्वतंत्र है।
• यदि squares[S] == S, या तो खिलाड़ी Sनहीं जा सकता है या नहीं ले जाएगा, या दो (या अधिक) खिलाड़ियों ने Sएक ही समय में स्थानांतरित करने की कोशिश की और दोनों को अस्वीकार कर दिया गया।
• अन्यथा, squares[S]उस वर्ग का सूचकांक होगा जिसमें से एक खिलाड़ी वर्ग में जाना चाहता है S।

प्रत्येक मोड़ पर, निम्न एल्गोरिथम की सभी प्रविष्टियों को आरंभीकृत squaresकरें NULLऔर फिर चलाएं:

for each player:
   current := the player's current location;
   target := the location the player wants to move to (may equal current);
   if squares[target] is NULL:
      squares[target] := current;  // target is free, mark planned move
   else
      // mark the target square as contested, and if necessary, follow
      // the pointers to cancel any moves affected by this:
      while not (target is NULL or squares[target] == target):
         temp := squares[target];
         squares[target] := target;
         target := temp;
      end while
      // mark this player as stationary, and also cancel any moves that
      // would require some else to move to this square
      while not (current is NULL or squares[current] == current):
         temp := squares[current];
         squares[current] := current;
         current := temp;
      end while
   end if
end for

उसके बाद, फिर से खिलाड़ियों की सूची के माध्यम से लूप करें, और उन लोगों को स्थानांतरित करें जो ऐसा करने में सक्षम हैं:

for each player:
   current := the player's current location;
   if not squares[current] == current:
       move player;
   end if
end for

चूंकि प्रत्येक चाल को केवल एक बार नियोजित किया जा सकता है और एक बार में रद्द कर दिया जाता है, इसलिए यह एल्गोरिथ्म सबसे खराब स्थिति में भी n खिलाड़ियों के लिए O ( n ) समय में चलेगा ।

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