ब्लॉक बिल्डिंग बॉट झुंड!


42

प्रतियोगिता खत्म हो गई है!

पहचान

यह एक इंटरेक्टिव प्रतियोगिता है, जहां नियंत्रक पूरी तरह से स्टैक स्निपेट में प्रश्न के निचले भाग में निहित होता है। नियंत्रक स्वचालित रूप से उत्तर पढ़ता है और गेम के माध्यम से खेलता है। कोई भी किसी भी समय अपने ब्राउज़र में इसे चला सकता है।

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

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

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

गेमप्ले

मूल बातें

इस सवाल का हर जवाब एक खिलाड़ी का प्रतिनिधित्व करता है । एक खेल दो खिलाड़ियों के बीच एक प्रतियोगिता है P1 और P2 । प्रत्येक खिलाड़ी 8 बॉट्स के झुंड को नियंत्रित करता है , 0 के माध्यम से 0 गिना जाता है। खेल ग्रिड में होता है , एक 128 × 64 सेल का अखाड़ा जिसकी नीचे की 8 पंक्तियाँ दीवारों ('ब्लॉक') के रूप में शुरू होती हैं और अन्य पंक्तियाँ हवा के रूप में शुरू होती हैं । ग्रिड सीमा के बाहर की कोशिकाओं को वायु माना जाता है।

ग्रिड का x समन्वय बाईं ओर 0 से दाईं ओर 127 तक है, और y 0 से लेकर शीर्ष पर 63 तक सबसे नीचे है।

नमूना शुरू ग्रिड:

बोट्स हमेशा ग्रिड कोशिकाओं से जुड़े रहते हैं और कई बॉट एक ही सेल पर कब्जा कर सकते हैं। बॉट केवल वायु कोशिकाओं पर कब्जा कर सकते हैं। P1 के बॉट हमेशा दीवारों के ऊपर की पंक्ति के बाईं ओर एक पंक्ति 0-4 में शुरू होते हैं और P2 के बॉट हमेशा एक पंक्ति में 7-0 से शुरू होते हैं।

पड़ोसियों को कोई बॉट या सेल के 8 कोशिकाओं को सीधे ओर्थोगोनल और इसे करने के लिए विकर्ण हैं।

एक बॉट का दृश्य ( FOV ) एक बॉट पर केंद्रित 13 × 13 सेल वर्ग है। एक सेल या दुश्मन बॉट को खिलाड़ी के FOV में कहा जाता है अगर यह खिलाड़ी के बॉट में से कम से कम एक FOV में हो।

चाल और कार्य

एक खेल के दौरान, प्रत्येक खिलाड़ी के पास जाए ले जाने के 1000 बार। पी 1 पहले चलता है, फिर पी 2, फिर पी 1 और इसी तरह 2000 तक कुल चालें बनी हैं, जिस बिंदु पर खेल समाप्त होता है।

एक चाल के दौरान, प्रत्येक खिलाड़ी अपने FOV में खेल की स्थिति और ग्रिड कोशिकाओं और दुश्मन बॉट के बारे में जानकारी प्राप्त करता है, और इसका उपयोग करने के लिए अपने प्रत्येक बॉट के लिए एक कार्रवाई पर निर्णय लेने के लिए इसका उपयोग करता है ।

डिफ़ॉल्ट कार्रवाई कुछ भी नहीं है , जहां बॉट ग्रिड के साथ स्थानांतरित या बातचीत नहीं करता है।

अन्य क्रियाएं मूव , ग्रैब और प्लेस हैं :

  • एक बॉट कर सकते हैं ले जाने के उसके पड़ोसी कोशिकाओं सी अगर से एक के लिए:

    • C सीमा से बाहर नहीं है,
    • सी हवा है (यानी एक दीवार नहीं),
    • और सी के पड़ोसियों में से कम से कम एक दीवार है।

    सफल होने पर, बोट C के पास चला जाएगा।

  • एक बॉट अपने पड़ोसी कोशिकाओं में से एक को पकड़ सकता है यदि:

    • C सीमा से बाहर नहीं है,
    • सी एक दीवार है,
    • और बॉट पहले से ही एक दीवार नहीं ले जा रहा है।

    सफल होने पर, C हवा हो जाएगी और बॉट अब एक दीवार ले जाएगा।

  • एक बॉट अपने पड़ोसी कोशिकाओं में से एक को स्थान दे सकता है यदि:

    • C सीमा से बाहर नहीं है,
    • सी हवा है,
    • या तो खिलाड़ी का कोई बॉट C नहीं है,
    • और बॉट एक दीवार ले जा रहा है।

    सफल होने पर, सी एक दीवार बन जाएगी और बॉट अब दीवार लेकर नहीं जाएगा।

असफल कार्यों के परिणामस्वरूप कुछ भी नहीं होता है।

कम से कम एक दीवार ढोने वाले बॉट के कब्जे वाले एक सेल में दीवार के एक छोटे से वर्ग को खींचा जाता है। बॉट बिना दीवारों के शुरू होते हैं।

याद

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

लक्ष्य

पीले क्रॉसहेयर में सेल लक्ष्य है , जो एक यादृच्छिक स्थिति में शुरू होता है। प्रत्येक खिलाड़ी का एक अंक होता है, जो 0. से शुरू होता है। जब किसी खिलाड़ी का बॉट गोल पर जाता है, तो उस खिलाड़ी का स्कोर 1 से बढ़ जाता है और अगले मोड़ से पहले लक्ष्य को बेतरतीब ढंग से रिप्लेस किया जाता है। एक खेल के अंत में उच्चतम स्कोर वाला खिलाड़ी जीतता है। यह एक टाई है अगर स्कोर बराबर हैं।

यदि एक मूव के दौरान कई बॉट गोल में जाते हैं, तो खिलाड़ी को केवल एक पॉइंट मिलता है।

यदि लक्ष्य 500 चालों के लिए एक ही स्थान पर रहा है, तो यह बेतरतीब ढंग से फिर से जमा हो जाता है। किसी भी समय लक्ष्य को बेतरतीब ढंग से तैनात किया जाता है, यह एक बॉट द्वारा कब्जा किए गए सेल पर नहीं रखे जाने की गारंटी है।

क्या प्रोग्राम करें

इस कार्य के लिए एक निकाय लिखें :

function myMove(p1, id, eid, move, goal, grid, bots, ebots, getMem, setMem) {
    //body goes here
}

यह उस समय कहा जाएगा जब आपका खिलाड़ी हर बार कदम उठाएगा और आपको उस कदम के दौरान अपने प्रत्येक बॉट को लेने की जरूरत है।

आप शुरुआती बिंदु के रूप में बेसलाइन कोड का उपयोग कर सकते हैं ।

पैरामीटर

  • p1एक बूल है कि trueअगर आप पी 1 हैं और falseअगर आप पी 2 हैं
  • id एक पूर्णांक है जो आपके उत्तर की उत्तर आईडी है।
    • आप नीचे दिए गए 'शेयर' लिंक पर क्लिक करके और a/URL के ठीक बाद वाले नंबर की तलाश करके किसी उत्तर की आईडी पा सकते हैं ।
    • टेस्ट एंट्री की आईडी -1 है।
  • eid एक पूर्णांक है जो आपके दुश्मन के उत्तर की आईडी है।
  • move 1 से 1000 तक पूर्णांक है जो कहता है कि आप किस चाल पर हैं।
  • goalxऔर yगुणों के साथ एक वस्तु है । ये लक्ष्य के समन्वय हैं। भले ही लक्ष्य आपके FOV से बाहर हो, उन्हें दिया जाता है।
  • gridएक फ़ंक्शन है जो x और y तर्क में लेता है, उदा grid(x,y)। यह रिटर्न:
    • -1'अज्ञात' के लिए यदि तर्क दो पूर्णांक नहीं हैं या यदि x,yआपके FOV में नहीं है।
    • 0'हवा' के लिए यदि x,yसीमा से बाहर है या यदि सेल x,yहवा में है।
    • 1'दीवार' के लिए अगर सेल x,yएक दीवार है।
  • botsआपके 8 बॉट की एक सरणी है। उसके तत्वों गुणों के साथ वस्तुओं रहे हैं x, yऔर hasWall:

    • xऔर yबॉट के निर्देशांक हैं।
    • hasWallहै trueअगर बॉट एक दीवार और ले जा रहा है falseनहीं तो।

    bots हमेशा आदेश दिया जाता है, Nth इंडेक्स बॉट नंबर N से मेल खाता है।

  • ebotsके साथ वस्तुओं की एक सरणी है x, yऔर hasWallगुण जैसे bots। आपके FOV में केवल दुश्मन बॉट हैं ebots। यदि आपके FOV में कोई दुश्मन बॉट नहीं है तो इसकी लंबाई 0 होगी। इसे बेतरतीब ढंग से ऑर्डर किया जाता है।
  • getMem बिना किसी तर्क के एक कार्य है जो आपकी स्मृति को लौटाता है।
  • setMem एक ऐसा फ़ंक्शन है जो एक तर्क लेता है। यदि एम 256 वर्णों या उससे कम का स्ट्रिंग है, तो आपकी मेमोरी को एम अपडेट किया जाता है, अन्यथा कुछ भी नहीं होता है।

consoleअकेले ब्राउज़र ऑब्जेक्ट टेस्ट एंट्री के लिए उपलब्ध है।

प्रतिलाभ की मात्रा

आपके फ़ंक्शन को ठीक 8 पूर्णांकों की एक सरणी वापस करने की आवश्यकता है, प्रत्येक 0 से 24 तक है। इंडेक्स एन पर मूल्य वह क्रिया है जो बॉट नंबर एन ले जाएगा।

यदि आपका कार्य हो तो आपके सभी बॉट कुछ नहीं करेंगे:

  • किसी भी तरह की त्रुटि को फेंक देता है। ( त्रुटि )
  • निष्पादित करने के लिए 20 मिलीसेकंड से अधिक समय लगता है । ( समय समाप्त )
  • 0 से 24 तक 8 पूर्णांकों की एक सरणी नहीं लौटाता है। ( विकृत )

सुविधा के लिए, किसी गेम के समाप्त होने पर त्रुटियों, समयबाह्य और विकृत क्रियाओं की संख्या प्रदर्शित की जाती है।

0 से 24 तक की प्रत्येक संख्या एक विशेष बॉट क्रिया से मेल खाती है:

  • 0 कुछ नहीं करने के लिए है।
  • 1-8 बढ़ने के लिए हैं।
  • 9-16 हथियाने के लिए हैं।
  • 17-24 रखने के लिए हैं।

यहाँ दिखाए गए अनुसार बॉट की पड़ोसी कोशिकाओं में से किसी एक को हिलाने, हथियाने और रखने के 8 मान हैं:

इसलिए, उदाहरण के लिए, 15बॉट के नीचे सेल को हथियाने के लिए कार्रवाई है।

बॉट क्रियाओं को क्रम बॉट 0 से बॉट 7 में संभाला जाता है। उदाहरण के लिए, अगर एक मूव के दौरान बॉट 0 को उसी एयर सेल में एक दीवार रखने के लिए कहा जाता है तो बॉट 1 को स्थानांतरित करने के लिए कहा गया था, बॉट से पहले एयर सेल एक दीवार बन जाएगी। 1 की कार्रवाई को नियंत्रित किया जाता है और बॉट 1 असफल हो जाएगा।

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

नियम

मैं इन नियमों का पालन नहीं करने वाले उपयोगकर्ताओं या उत्तरों को अस्थायी या स्थायी रूप से अयोग्य ठहरा सकता हूं । अयोग्य प्रविष्टियां जीतने के योग्य नहीं हैं।

  • चरों या कार्यों की घोषणा करते समय, आपको varखोजशब्द का उपयोग करना चाहिए ।
    जैसे var x = 10या var sum = function(a, b){ return a + b }
    बिना घोषित की varगई चीजें वैश्विक हो जाती हैं और नियंत्रक के साथ हस्तक्षेप कर सकती हैं। कदम उठाए गए हैं ताकि यह हस्तक्षेप असंभव हो, लेकिन यह सुनिश्चित करने के लिए ऐसा करें।

  • आपका कोड धीरे-धीरे या बेकार समय नहीं चलना चाहिए।
    जावास्क्रिप्ट कार्यों को मध्य-निष्पादन को रोकना असंभव है, इसलिए प्रत्येक खिलाड़ी का कोड पूरा होने के लिए चलाया जाता है। यदि आपके कोड को चलाने में लंबा समय लगता है, तो आपके खिलाड़ी को चलाने वाला हर कोई नोटिस करेगा और नाराज होगा। आदर्श रूप से, प्रविष्टियां हमेशा 20ms की सीमा के भीतर अच्छी तरह से चलेंगी।

  • आपको फ़ायरफ़ॉक्स के नवीनतम संस्करण में ECMAScript 5 के साथ संगत कोड का उपयोग करना चाहिए क्योंकि यह वह जगह है जहाँ मैं इसे चला रहा हूँ। ECMAScript 6 से सुविधाओं का उपयोग न करें क्योंकि यह अभी तक कई ब्राउज़रों में समर्थित नहीं है।
  • आप 3 बार तक जवाब दे सकते हैं , लेकिन केवल तभी जब आपकी प्रत्येक रणनीति काफी अलग हो। आप वांछित के रूप में उत्तर संपादित कर सकते हैं।
  • आप किसी भी प्रकार की मेमोरी का उपयोग करने के अलावा getMemऔर करने की कोशिश नहीं कर सकते हैं setMem
  • आप नियंत्रक, अन्य खिलाड़ी के कोड, या बाहरी संसाधनों को एक्सेस या संशोधित करने का प्रयास नहीं कर सकते हैं।
  • आप जावास्क्रिप्ट में निर्मित कुछ भी संशोधित करने का प्रयास नहीं कर सकते हैं।
  • उत्तर निर्धारित करने की आवश्यकता नहीं है। आप उपयोग कर सकते हैं Math.random

उत्तर प्रारूप

#EntryName

Notes, etc.

<!-- language: lang-js -->

    //function body
    //probably on multiple lines

More notes, etc.

पहले मल्टीलाइन कोड ब्लॉक में आपका फ़ंक्शन बॉडी होना चाहिए।
प्रवेश नाम 20 वर्णों तक सीमित है।

आपकी प्रविष्टि शीर्षक के साथ नियंत्रक में दिखाई देगी EntryName - Username [answer ID], साथ ही [DQ]अगर वह अयोग्य है।

जीतना

जब प्रश्न कम से कम 3 सप्ताह के लिए हो और एक बार जवाब देने के बाद बस गया हो, तो मैं चैंपियन को ताज पहनाऊंगा।

मैं नियंत्रक के ऑटोरन सुविधा का उपयोग करूंगा । ऑटोरन राउंड में, प्रत्येक गैर-अयोग्य खिलाड़ी हर दूसरे के साथ दो गेम खेलता है, पी 1 के रूप में, एक पी 2 (एक डबल राउंड-रॉबिन) के रूप में।

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

मैं विंडोज 8.1 64-बिट, 4 जीबी रैम और 1.6 जीएचजेड क्वाड-कोर प्रोसेसर वाले लैपटॉप पर फ़ायरफ़ॉक्स का उपयोग कर रहा हूं।

इनाम

मैं पीपीसीजी चुनौती लिखूंगा और पोस्ट करूंगा, विशेष रूप से चैंपियन को समर्पित। यह किसी तरह उनके उपयोगकर्ता नाम या अवतार या उनके बारे में कुछ शामिल करेगा। मैं निजी तौर पर यह तय करूंगा कि जब यह प्रतियोगिता समाप्त होगी तो चुनौती क्या होगी। मैं इसे अपनी क्षमता के अनुसार लिखूंगा और यह सुनिश्चित करने का प्रयास करूंगा कि यह एक हॉट नेटवर्क प्रश्न बन जाए।

नियंत्रक

इस स्निपेट को चलाएं या नियंत्रक का उपयोग करने के लिए इस JSField पर जाएं। यह यादृच्छिक खिलाड़ियों के साथ शुरू होता है। मैंने इसे फ़ायरफ़ॉक्स और क्रोम में अच्छी तरह से परखा है।

<style>html *{font-family:Consolas,Arial,sans-serif}canvas{margin:6px}button,input table,select{font-size:100%}textarea{font-family:monospace}input[type=text],textarea{padding:2px}textarea[readonly]{background-color:#eee}select{width:250pt;margin:3px 0}input[type=radio]{vertical-align:-.25em}input[type=checkbox]{vertical-align:-.15em}.c{margin:12px}.h{font-size:125%;font-weight:700}#main td{padding:12px;text-align:left}#main table{margin-left:auto;margin-right:auto}#main{text-align:center}#title{margin:12px;font-size:175%;font-weight:700;color:#333}#delay{text-align:right}#statsTable table{border-collapse:collapse}#statsTable td{border:1px solid gray;padding:3pt;font-family:monospace;text-align:center}#footnotes{margin:18px 0 0;font-size:75%}#arWrapper{border:2px solid red;background-color:#fff4f4}</style><div id=loadStatus>Loading entries...</div><div id=main><div id=title>Block Building Bot Flocks</div><div><span id=p1Title class=p1Color></span> vs. <span id=p2Title class=p2Color></span></div><canvas id=canvas>Canvas unsupported!</canvas><div><span id=p1Score class=p1Color>0</span> | <span id=moveCounter>0</span> | <span id=p2Score class=p2Color>0</span></div><div class=c><button id=runPause type=button onclick=runPause()>Run</button> <button id=moveOnce type=button onclick=moveOnce()>Move Once</button> <button type=button onclick=newGame()>New Game</button></div><div class=c><input id=delay size=4 value=20> ms delay <input id=showNumbers type=checkbox onclick=toggleNumbers()><label for=showNumbers>Show bot numbers</label>&nbsp;<input id=showLOS type=checkbox onclick=toggleLOS()><label for=showLOS>Show field of view</label></div><table><tr><td><div id=p1Header class="p1Color h">Player 1</div><div><select id=p1Select onchange=changeSelect(!0)></select></div><div><a id=p1Link href=javascript:;>Answer Link</a></div><td><div id=p2Header class="p2Color h">Player 2</div><div><select id=p2Select onchange=changeSelect(!1)></select></div><div><a id=p2Link href=javascript:;>Answer Link</a></div></table><div>Test Entry</div><div><textarea id=testEntry rows=8 cols=64>return [0,0,0,0,0,0,0,0]</textarea></div><div class=c><button type=button onclick=autorun()>Autorun N Rounds</button> N&nbsp;=&nbsp;<input id=N size=4 value=1> <input id=arTestEntry type=checkbox><label for=arTestEntry>Include Test Entry</label></div><div id=footnotes><input id=debug type=checkbox onclick=toggleDebug()><label for=debug>Console debug messages</label>&nbsp;| Scale: <input id=sc1 type=radio name=sc value=1><label for=sc1>Micro</label><input id=sc3 type=radio name=sc value=3><label for=sc3>Small</label><input id=sc6 type=radio name=sc value=6 checked><label for=sc6>Normal</label><input id=sc9 type=radio name=sc value=9><label for=sc9>Large</label>&nbsp;| Colors: <input id=normalCo type=radio name=co value=normal checked><label for=normalCo>Normal</label><input id=pastelCo type=radio name=co value=pastel><label for=pastelCo>Pastels</label><input id=neonCo type=radio name=co value=neon><label for=neonCo>Neon</label>&nbsp; <button type=button onclick=reload()>Reload</button><div id=invalidWrapper><br>No entry name/code found: <span id=invalid></span></div></div></div><div id=arWrapper><div id=arInfo class=c>Autorun in progress. Running game <span id=arProgress></span>.</div><div id=arResults><div class="c h">Autorun Results</div><div class=c>Players: <span id=arPlayers></span><br>Rounds: <span id=arRounds></span><br>Games per round: <span id=arGpR></span><br>Total games: <span id=arTotal></span><br></div><div class=c><strong>Leaderboard:</strong></div><div id=leaderboard class=c></div><div class=c>(W = wins, T = ties, L = losses, G = total goals, E = errors, I = timeouts, M = malformed actions, F = failed actions)</div><div class=c><strong>Player vs. Player Statistics:</strong></div><div id=statsTable class=c></div><div class=c>The top row has the ID's of P1.<br>The left column has the ID's of P2.<br>Every other cell not on the diagonal has the form "[P1 win count] [tie count] [P2 win count]".</div><div class=c><button type=button onclick=closeAutorun()>Close</button></div></div></div><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><script>function setGlobals(e){G={},G.QID=50690,G.SITE="codegolf",G.DQ_ANSWERS=[],G.DQ_USERS=[],G.DEBUG=Q("#debug").is(":checked"),G.SHOW_NUMBERS=Q("#showNumbers").is(":checked"),G.SHOW_LOS=Q("#showLOS").is(":checked"),G.BOTS=8,G.LOS=6,G.W=128,G.H=64,G.SCALE=e?6:parseInt(Q('input[name="sc"]:checked').val()),G.CW=G.SCALE*G.W,G.CH=G.SCALE*G.H,G.TOTAL_MOVES=2e3,G.GOAL_LIFESPAN=500,G.MEM_MAX_LENGTH=256,G.TIME_LIMIT=20;var t=Q('input[name="co"]:checked').val();e||"normal"===t?G.COLORS={AIR:"#ccc",WALL:"#888",GOAL:"rgba(255,255,0,0.6)",BG:"#f7f7f7",P1:"#00f",P1_TEXT:"#008",P1_LOS:"rgba(0,0,255,0.1)",P2:"#f00",P2_TEXT:"#800",P2_LOS:"rgba(255,0,0,0.1)"}:"pastel"===t?G.COLORS={AIR:"#cef0ff",WALL:"#66cc66",GOAL:"rgba(0,0,0,0.3)",BG:"#fdfde6",P1:"#f4a034",P1_TEXT:"#a35f00",P1_LOS:"rgba(255,179,71,0.2)",P2:"#f67cf6",P2_TEXT:"#b408b4",P2_LOS:"rgba(249,128,249,0.2)"}:"neon"===t&&(G.COLORS={AIR:"#000",WALL:"#444",GOAL:"rgba(255,255,0,0.9)",BG:"#999",P1:"#0f0",P1_TEXT:"#5f5",P1_LOS:"rgba(255,128,0,0.15)",P2:"#f0f",P2_TEXT:"#f5f",P2_LOS:"rgba(0,255,255,0.15)"}),G.SCOREBOARD={P1SCORE:void 0,MOVE:void 0,P2SCORE:void 0},G.CTX=void 0,G.PLAYERS=void 0,G.GAME=void 0,G.TIMER=void 0,G.RUNNING=!1}function reload(){var e="undefined"==typeof G;e||stopTimer(),setGlobals(e);var t=Q("#canvas");t.width(G.CW).height(G.CH).prop({width:G.CW,height:G.CH}),G.CTX=t[0].getContext("2d"),G.CTX.font=(2*G.SCALE).toString()+"px Courier New",G.SCOREBOARD.P1SCORE=Q("#p1Score"),G.SCOREBOARD.MOVE=Q("#moveCounter"),G.SCOREBOARD.P2SCORE=Q("#p2Score"),Q("body").css("background-color",G.COLORS.BG),Q(".p1Color").css("color",G.COLORS.P1),Q(".p2Color").css("color",G.COLORS.P2),Q("#invalidWrapper").hide(),Q("#arWrapper").hide(),loadAnswers(G.SITE,G.QID,function(e){Q.isArray(e)?(Q("#loadStatus").remove(),loadPlayers(e),newGame()):Q("#loadStatus").text("Error loading entries - "+e)})}function maskedEval(e,t){var r={};for(i in this)r[i]=void 0;for(i in t)t.hasOwnProperty(i)&&(r[i]=t[i]);return new Function("with(this) { "+e+";}").call(r)}function toKey(e,t){return G.W*t+e}function fromKey(e){return{x:e%G.W,y:Math.floor(e/G.W)}}function outOfBounds(e,t){return 0>e||e>=G.W||0>t||t>=G.H}function rnd(e){return Math.floor(Math.random()*e)}function isInt(e){return"number"==typeof e&&e%1===0}function isString(e){return"string"==typeof e||e instanceof String}function decode(e){return Q("<textarea>").html(e).text()}function shuffle(e){for(var t,r,o=e.length;o;t=rnd(o),r=e[--o],e[o]=e[t],e[t]=r);}function makeTable(e){for(var t=Q("<table>"),r=0;r<e.length;r++){for(var o=Q("<tr>"),a=0;a<e[r].length;a++)o.append(Q("<td>").text(e[r][a]));t.append(o)}return t}function toggleDebug(){G.DEBUG=Q("#debug").is(":checked")}function toggleNumbers(){G.SHOW_NUMBERS=Q("#showNumbers").is(":checked"),drawGame(G.GAME)}function toggleLOS(){G.SHOW_LOS=Q("#showLOS").is(":checked"),drawGame(G.GAME)}function closeAutorun(){Q("#arWrapper").hide(),Q("#main").show()}function changeSelect(e){var t=Q(e?"#p1Select":"#p2Select").val(),r=Q(e?"#p1Link":"#p2Link");null===t&&0>t?r.attr("href","javascript:;"):r.attr("href",G.PLAYERS[t].link)}function stopTimer(){"undefined"!=typeof G.TIMER&&clearInterval(G.TIMER)}function moveOnce(){gameOver(G.GAME)||(moveGame(G.GAME),drawGame(G.GAME),gameOver(G.GAME)&&(stopTimer(),Q("#runPause").text("Run").prop("disabled",!0),Q("#moveOnce").prop("disabled",!0),G.DEBUG&&console.log("======== GAME OVER: "+G.GAME.p1.score+" TO "+G.GAME.p2.score+" ========"),alert(gameOverMessage(G.GAME))))}function runPause(){if(G.RUNNING)stopTimer(),Q("#runPause").text("Run"),Q("#moveOnce").prop("disabled",!1);else{var e=parseInt(Q("#delay").val());if(isNaN(e)||0>e)return void alert("Delay must be a non-negative integer.");Q("#runPause").text("Pause"),Q("#moveOnce").prop("disabled",!0),G.TIMER=setInterval(moveOnce,e)}G.RUNNING=!G.RUNNING}function newGame(){stopTimer();var e=G.PLAYERS[Q("#p1Select").val()],t=G.PLAYERS[Q("#p2Select").val()];G.RUNNING=!1,Q("#runPause").text("Run").prop("disabled",!1),Q("#moveOnce").prop("disabled",!1),Q("#p1Title").text(e.title),Q("#p2Title").text(t.title),G.GAME=createGame(e,t),drawGame(G.GAME)}function tryParse(e,t){var r=parseInt(Q(e).val());return!isNaN(r)&&r>=0?r:void alert(t+" must be a non-negative integer.")}function autorun(){function e(){for(var e=new Array(a.length),t={},r=["wins","goals","errors","timeouts","malformed","invalid"],n=0;n<e.length;n++){t.wins=t.ties=t.losses=t.goals=t.errors=t.timeouts=t.malformed=t.invalid=0;for(var l=0;l<e.length;l++)n!==l&&(t.ties+=s[n][l].ties+s[l][n].ties,t.losses+=s[n][l].p2.wins+s[l][n].p1.wins,r.forEach(function(e){t[e]+=s[n][l].p1[e]+s[l][n].p2[e]}));e[n]={wins:t.wins,text:a[n].title+" : "+t.wins+"W, "+t.ties+"T, "+t.losses+"L, "+t.goals+"G, "+t.errors+"E, "+t.timeouts+"I, "+t.malformed+"M, "+t.invalid+"F"}}e=e.sort(function(e,t){return t.wins-e.wins}).map(function(t,r){return r+1+". "+t.text+(r<e.length-1?"<br>":"")});for(var i=new Array(s.length+1),G=0;G<i.length;G++){i[G]=new Array(s.length+1);for(var c=0;c<i.length;c++){var f;i[G][c]=0===c&&0===G?"P2\\P1":0===c?a[G-1].id:0===G?a[c-1].id:(f=s[c-1][G-1])?f.p1.wins+" "+f.ties+" "+f.p2.wins:"-"}}Q("#arPlayers").text(a.length),Q("#arRounds").text(o),Q("#arGpR").text(S/o),Q("#arTotal").text(S),Q("#leaderboard").empty().append(e),Q("#statsTable").empty().append(makeTable(i)),Q("#arInfo").hide(),Q("#arResults").show()}function t(e,t){for(var r=createGame(a[e],a[t]);!gameOver(r);)moveGame(r);r.p1.score>r.p2.score?s[e][t].p1.wins++:r.p1.score<r.p2.score?s[e][t].p2.wins++:s[e][t].ties++,["p1","p2"].forEach(function(o){s[e][t][o].goals+=r[o].score,s[e][t][o].errors+=r[o].stats.errors,s[e][t][o].timeouts+=r[o].stats.timeouts,s[e][t][o].malformed+=r[o].stats.malformed,s[e][t][o].invalid+=r[o].stats.invalid.reduce(function(e,t){return e+t},0)})}function r(){if(c!==f&&(t(c,f),++p<=S&&Q("#arProgress").text(p+"/"+S)),f+1<a.length)f++;else if(f=0,c+1<a.length)c++;else{if(c=0,!(o>i+1))return void e();i++}setTimeout(r,0)}var o=parseInt(Q("#N").val());if(isNaN(o)||1>o)return void alert("N must be a positive integer.");var a=[];Q("#arTestEntry").is(":checked")&&a.push(G.PLAYERS[0]);for(var n=1;n<G.PLAYERS.length;n++)G.PLAYERS[n].dq||a.push(G.PLAYERS[n]);for(var s=new Array(a.length),n=0;n<a.length;n++){s[n]=new Array(a.length);for(var l=0;l<a.length;l++)n!==l&&(s[n][l]={ties:0,p1:{wins:0,goals:0,errors:0,timeouts:0,malformed:0,invalid:0},p2:{wins:0,goals:0,errors:0,timeouts:0,malformed:0,invalid:0}})}var i=0,c=0,f=0,p=1,S=o*a.length*(a.length-1);Q("#arProgress").text("1/"+S),Q("#main").hide(),Q("#arInfo").show(),Q("#arResults").hide(),Q("#arWrapper").show(),setTimeout(r,0)}function gameOver(e){return e.move>=G.TOTAL_MOVES}function gameOverMessage(e){function t(e,t){return"P"+(t?1:2)+": "+e.entry.title+"\nScore: "+e.score+"\nErrors: "+e.stats.errors+"\nTimeouts: "+e.stats.timeouts+"\nMalformed actions: "+e.stats.malformed+"\nFailed actions: ["+e.stats.invalid.toString().replace(/,/g,", ")+"]"}var r="GAME OVER - ";return r+=e.p1.score>e.p2.score?"PLAYER 1 WINS":e.p1.score<e.p2.score?"PLAYER 2 WINS":"TIE GAME",r+="\n\n"+t(e.p1,!0)+"\n\n"+t(e.p2,!1)}function createGame(e,t){function r(e){return{entry:e,bots:new Array(G.BOTS),mem:"",score:0,stats:{errors:0,timeouts:0,malformed:0,invalid:Array.apply(null,new Array(G.BOTS)).map(Number.prototype.valueOf,0)}}}var o={},a=Math.floor(.875*G.H)-1;o.move=0,o.walls=new Array(G.H);for(var n=0;n<G.H;n++){o.walls[n]=new Array(G.W);for(var s=0;s<G.W;s++)o.walls[n][s]=n>a}o.p1=r(e),o.p2=r(t);for(var l=0;l<G.BOTS;l++)o.p1.bots[l]={x:l,y:a,hasWall:!1},o.p2.bots[l]={x:G.W-1-l,y:a,hasWall:!1};if(-1===o.p1.entry.id||-1===o.p2.entry.id){var i=decode(Q("#testEntry").val());-1===o.p1.entry.id&&(o.p1.entry.code=i),-1===o.p2.entry.id&&(o.p2.entry.code=i)}return resetGoal(o),G.DEBUG&&console.log("======== NEW GAME: "+o.p1.entry.title+" VS "+o.p2.entry.title+" ========"),o}function moveGame(e){movePlayer(e,++e.move%2===1),++e.goal.age>=G.GOAL_LIFESPAN&&resetGoal(e)}function setupParams(e,t){function r(e,t){var r=toKey(e,t);if(!n.hasOwnProperty(r)){n[r]=!1;for(var a=0;a<G.BOTS;a++)if(Math.abs(o.bots[a].x-e)<=G.LOS&&Math.abs(o.bots[a].y-t)<=G.LOS){n[r]=!0;break}}return n[r]}var o=t?e.p1:e.p2,a=t?e.p2:e.p1,n={},s={};s.p1=t,s.id=o.entry.id,s.eid=a.entry.id,s.score=o.score,s.escore=a.score,s.move=Math.floor((e.move+1)/2),s.goal={x:e.goal.x,y:e.goal.y},s.getMem=function(){return o.mem},s.setMem=function(e){isString(e)&&e.length<=G.MEM_MAX_LENGTH&&(o.mem=e)},s.grid=function(t,o){return isInt(t)&&isInt(o)&&r(t,o)?outOfBounds(t,o)?0:e.walls[o][t]?1:0:-1},s.bots=new Array(G.BOTS),s.ebots=[];for(var l=0;l<G.BOTS;l++)s.bots[l]={x:o.bots[l].x,y:o.bots[l].y,hasWall:o.bots[l].hasWall},r(a.bots[l].x,a.bots[l].y)&&s.ebots.push({x:a.bots[l].x,y:a.bots[l].y,hasWall:a.bots[l].hasWall});return shuffle(s.ebots),-1===o.entry.id&&(s.console=console),s}function movePlayer(e,t){var r,o,a=t?e.p1:e.p2,n=t?e.p2:e.p1,s=setupParams(e,t);G.DEBUG&&(console.log("######## MOVE "+e.move+" - P"+(t?1:2)+" ########"),console.log("PARAMETERS:"),console.log(s)),o=performance.now();try{r=maskedEval(a.entry.code,s)}catch(n){return a.stats.errors++,void(G.DEBUG&&(console.log("!!!! ERRORED !!!!"),console.log(n)))}if(o=performance.now()-o,G.DEBUG&&console.log("TIME TAKEN: "+o+"ms"),o>G.TIME_LIMIT)return a.stats.timeouts++,void(G.DEBUG&&console.log("!!!! TIMED OUT !!!!"));if(G.DEBUG&&(console.log("ACTIONS:"),console.log(r)),!Array.isArray(r)||r.length!==G.BOTS)return a.stats.malformed++,void(G.DEBUG&&console.log("!!!! MALFORMED ACTIONS !!!!"));for(var l=0;l<G.BOTS;l++)if(!isInt(r[l])||r[l]<0||r[l]>24)return a.stats.malformed++,void(G.DEBUG&&console.log("!!!! MALFORMED ACTIONS !!!!"));performActions(e,a,r)}function performActions(e,t,r){function o(e){t.stats.invalid[e]++,G.DEBUG&&console.log("!! BOT"+e+" ACTION FAILED !!")}function a(e){return e.x!==i||e.y!==c}for(var n=!1,s=0;s<G.BOTS;s++){var l=r[s];if(l){var i,c;switch((l-1)%8){case 0:i=-1,c=-1;break;case 1:i=0,c=-1;break;case 2:i=1,c=-1;break;case 3:i=-1,c=0;break;case 4:i=1,c=0;break;case 5:i=-1,c=1;break;case 6:i=0,c=1;break;case 7:i=1,c=1}if(i+=t.bots[s].x,c+=t.bots[s].y,outOfBounds(i,c))o(s);else switch(Math.floor((l-1)/8)){case 0:!e.walls[c][i]&&(i>0&&c>0&&e.walls[c-1][i-1]||c>0&&e.walls[c-1][i]||i<G.W-1&&c>0&&e.walls[c-1][i+1]||i>0&&e.walls[c][i-1]||i<G.W-1&&e.walls[c][i+1]||i>0&&c<G.H-1&&e.walls[c+1][i-1]||c<G.H-1&&e.walls[c+1][i]||i<G.W-1&&c<G.H-1&&e.walls[c+1][i+1])?(t.bots[s].x=i,t.bots[s].y=c,i!==e.goal.x||c!==e.goal.y||n||(n=!0,G.DEBUG&&console.log("** BOT"+s+" REACHED GOAL **"))):o(s);break;case 1:e.walls[c][i]&&!t.bots[s].hasWall?(e.walls[c][i]=!1,t.bots[s].hasWall=!0):o(s);break;case 2:!e.walls[c][i]&&t.bots[s].hasWall&&e.p1.bots.every(a)&&e.p2.bots.every(a)?(e.walls[c][i]=!0,t.bots[s].hasWall=!1):o(s)}}}n&&(t.score++,resetGoal(e)),G.DEBUG&&(console.log("FINAL PLAYER STATE:"),console.log(t))}function resetGoal(e){for(var t={},r=[],o=0;o<G.BOTS;o++)t[toKey(e.p1.bots[o].x,e.p1.bots[o].y)]=!0,t[toKey(e.p2.bots[o].x,e.p2.bots[o].y)]=!0;for(var a=0;a<G.H;a++)for(var n=0;n<G.W;n++){var s=toKey(n,a);t.hasOwnProperty(s)||r.push(s)}var l=fromKey(r[rnd(r.length)]);e.goal={age:0,x:l.x,y:l.y}}function drawGame(e){function t(e,t){G.CTX.fillRect(e*G.SCALE,t*G.SCALE,G.SCALE,G.SCALE)}function r(e,t){G.CTX.fillRect(e*G.SCALE+1,t*G.SCALE+1,G.SCALE-2,G.SCALE-2)}G.CTX.fillStyle=G.COLORS.AIR,G.CTX.fillRect(0,0,G.CW,G.CH),G.CTX.fillStyle=G.COLORS.WALL;for(var o=0;o<G.H;o++)for(var a=0;a<G.W;a++)e.walls[o][a]&&t(a,o);if(G.SHOW_LOS){var n=(2*G.LOS+1)*G.SCALE;G.CTX.fillStyle=G.COLORS.P1_LOS;for(var s=0;s<G.BOTS;s++)G.CTX.fillRect((e.p1.bots[s].x-G.LOS)*G.SCALE,(e.p1.bots[s].y-G.LOS)*G.SCALE,n,n);G.CTX.fillStyle=G.COLORS.P2_LOS;for(var s=0;s<G.BOTS;s++)G.CTX.fillRect((e.p2.bots[s].x-G.LOS)*G.SCALE,(e.p2.bots[s].y-G.LOS)*G.SCALE,n,n)}G.CTX.fillStyle=G.COLORS.P1;for(var s=0;s<G.BOTS;s++)t(e.p1.bots[s].x,e.p1.bots[s].y);G.CTX.fillStyle=G.COLORS.P2;for(var s=0;s<G.BOTS;s++)t(e.p2.bots[s].x,e.p2.bots[s].y);G.CTX.fillStyle=G.COLORS.WALL;for(var s=0;s<G.BOTS;s++)e.p1.bots[s].hasWall&&r(e.p1.bots[s].x,e.p1.bots[s].y),e.p2.bots[s].hasWall&&r(e.p2.bots[s].x,e.p2.bots[s].y);if(G.SHOW_NUMBERS){var l=-.1,i=2.75;G.CTX.fillStyle=G.COLORS.P1_TEXT;for(var s=0;s<G.BOTS;s++)G.CTX.fillText(s.toString(),(e.p1.bots[s].x+l)*G.SCALE,(e.p1.bots[s].y+i)*G.SCALE);G.CTX.fillStyle=G.COLORS.P2_TEXT;for(var s=0;s<G.BOTS;s++)G.CTX.fillText(s.toString(),(e.p2.bots[s].x+l)*G.SCALE,(e.p2.bots[s].y+i)*G.SCALE)}G.CTX.fillStyle=G.COLORS.GOAL,t(e.goal.x+1,e.goal.y),t(e.goal.x-1,e.goal.y),t(e.goal.x,e.goal.y+1),t(e.goal.x,e.goal.y-1),G.SCOREBOARD.P1SCORE.text(e.p1.score),G.SCOREBOARD.MOVE.text(e.move),G.SCOREBOARD.P2SCORE.text(e.p2.score)}function loadPlayers(e){var t=/<pre\b[^>]*><code\b[^>]*>([\s\S]*?)<\/code><\/pre>/,r=/<h1\b[^>]*>(.*?)<\/h1>/;G.PLAYERS=[];var o={id:-1,dq:!1,code:void 0,link:"javascript:;",title:"TEST ENTRY [-1]"};G.PLAYERS.push(o);var a=[];e.forEach(function(e){var o=decode(e.owner.display_name),n=t.exec(e.body),s=r.exec(e.body);if(null===n||n.length<=1||null===s||s.length<=1)return a.push(" "),void a.push(Q("<a>").text(o).attr("href",e.link));var l={};l.id=e.answer_id,l.dq=G.DQ_ANSWERS.indexOf(e.answer_id)>-1||G.DQ_USERS.indexOf(e.owner.user_id)>-1,l.code=decode(n[1]),l.link=e.link,l.title=s[1].substring(0,20)+" - "+o+" ["+l.id.toString()+"]",l.dq&&(l.title+="[DQ]"),G.PLAYERS.push(l)}),a.length>0&&(Q("#invalid").empty().append(a),Q("#invalidWrapper").show());for(var n=new Array(G.PLAYERS.length),s=new Array(G.PLAYERS.length),l=0;l<G.PLAYERS.length;l++)n[l]=Q("<option>").text(G.PLAYERS[l].title).val(l),s[l]=Q("<option>").text(G.PLAYERS[l].title).val(l);Q("#p1Select").empty().append(n).val(rnd(G.PLAYERS.length)),changeSelect(!0),Q("#p2Select").empty().append(s).val(rnd(G.PLAYERS.length)),changeSelect(!1)}function loadAnswers(e,t,r){function o(){Q.get("https://api.stackexchange.com/2.2/questions/"+t.toString()+"/answers?page="+(s++).toString()+"&pagesize=100&order=asc&sort=creation&site="+e+"&filter=!YOKGPOBC5Yad4mOOn8Z4WcAE6q",a)}function a(e){e.hasOwnProperty("error_id")?r(e.error_id.toString()):(n=n.concat(e.items),e.hasMore?o():r(n))}var n=[],s=1;o(s,a)}Q=jQuery,Q(reload);</script>

इस सवाल का अपना एक चैटरूम है। मैं हर कुछ दिनों में लीडरबोर्ड पोस्ट करता हूँ।



3
ग्रिड के आकार को समायोजित करने के लिए बटन के लिए धन्यवाद, मैं अपने फोन पर स्टैक स्निपेट चला सकता हूं :)
ट्राइकोप्लाक्स

3
बहुत सारा प्यार (codegolf.stackexchange.com/questions/50768/) लेकिन यह आसान नहीं है
edc65

3
यह देखने के लिए मंत्रमुग्ध है।
DLosc

1
@ स्टीफन हाँ। नियम बुलेट 4: "आप उत्तरों को इच्छानुसार संपादित कर सकते हैं।"
केल्विन के शौक

जवाबों:


13

ब्लैक नाइट

बॉट का नाम एक शुरुआती योजना से आया है, ताकि यह शतरंज के शूरवीर की तरह आगे बढ़ने में सक्षम हो: दो से अधिक, एक, आदि, जो कुछ मामलों में तेज होगा।

var moves = new Array(8),
    mem = getMem(), newMem = '';

var decodeMem = function(){
  //mmtxy
  for(var ind = 0; ind < 8; ind++){
    var sub = mem.substr(ind * 5, 5)
    bots[ind].lastMove = parseInt(sub[0], 36);
    bots[ind].last2Move = parseInt(sub[1], 36);
    bots[ind].timesStill = sub.charCodeAt(2) - 48;
    bots[ind].lastX = sub.charCodeAt(3) - 187;
    bots[ind].lastY = sub.charCodeAt(4) - 187;
  }
}
decodeMem();

var distanceTo = function(fromX, fromY, toX, toY){
  // Chebyshev distance
  return Math.max(Math.abs(fromX - toX),
                  Math.abs(fromY - toY));
}

var direction = function(from, to){ // Math.sign()
  var diff = to - from;
  return diff > 0 ? 1 : (diff < 0 ? -1 : 0);
}

var dirs = [
  [1, 2, 3],
  [4, 0, 5],
  [6, 7, 8]
];

var moveTo = function(from, to){
  var prioritiesWall = [
    [0],
    [1, 2, 4, 17, 18, 20, 19, 22, 23, 21, 3, 6, 5, 7, 24, 8],
    [2, 3, 1, 17, 19, 18, 23, 22, 24, 4, 5, 20, 21, 6, 8, 7],
    [3, 2, 5, 19, 18, 21, 17, 24, 23, 20, 1, 8, 4, 7, 22, 6],
    [4, 1, 6, 22, 17, 20, 21, 24, 19, 2, 7, 18, 23, 3, 8, 5],
    [5, 3, 8, 24, 19, 21, 20, 22, 17, 2, 7, 18, 23, 1, 6, 4],
    [6, 4, 7, 22, 20, 23, 17, 24, 18, 21, 1, 8, 2, 5, 19, 3],
    [7, 8, 6, 22, 24, 23, 18, 17, 19, 4, 5, 20, 21, 1, 3, 2],
    [8, 5, 7, 24, 21, 23, 19, 22, 18, 20, 3, 6, 2, 4, 17, 1]
  ];
  var prioritiesNoWall = [
    [9, 10, 11, 12, 13, 14, 15, 16, 0],
    [1, 2, 4, 9, 16, 10, 12, 3, 6, 11, 14, 5, 7, 13, 15, 8],
    [2, 3, 1, 10, 15, 14, 16, 4, 5, 12, 13, 9, 11, 6, 8, 7],
    [3, 2, 5, 11, 14, 10, 13, 1, 8, 9, 16, 4, 7, 12, 15, 6],
    [4, 1, 6, 12, 13, 16, 11, 2, 7, 10, 15, 9, 14, 3, 8, 5],
    [5, 3, 8, 13, 12, 14, 9, 2, 7, 10, 15, 11, 16, 1, 6, 4],
    [6, 4, 7, 14, 11, 12, 15, 1, 8, 9, 16, 2, 5, 10, 13, 3],
    [7, 8, 6, 15, 10, 9, 11, 4, 5, 12, 13, 14, 16, 1, 3, 2],
    [8, 5, 7, 16, 9, 13, 15, 3, 6, 11, 14, 2, 4, 10, 12, 1]
  ];

  var dir = dirs[direction(from.y, to.y) + 1][direction(from.x, to.x) + 1],
      method = from.hasWall ? prioritiesWall[dir] : prioritiesNoWall[dir];

  if(distanceTo(from.x, from.y, goal.x, goal.y) === 1){
    method.splice(1,2);
  }

  for(var i=0; i<method.length; i++){
    var attempt = method[i];
    if(checkMove(from, attempt)) return attempt;
  }
  return 0;
}

var numWalls = function(x, y, indexes){
  var allCoords = [
    [x - 1, y - 1],
    [x,     y - 1],
    [x + 1, y - 1],
    [x - 1, y    ],
    [x + 1, y    ],
    [x - 1, y + 1],
    [x,     y + 1],
    [x + 1, y + 1],
  ];
  var allTypes = allCoords.map(function(e){
    return grid(e[0], e[1]); // air = 0, wall = 1
  });
  var justWalls = allTypes.filter(function(e){
    return e === 1;
  }).length;

  return indexes ? allTypes : justWalls;
}

var checkMove = function(coords, moveCode){
  var x = coords.x, y = coords.y,
      baseX = [0, -1, 0, 1, -1, 1, -1, 0, 1],
      baseY = [0, -1, -1, -1, 0, 0, 1, 1, 1],
      targetX = x + baseX[(moveCode - 1) % 8 + 1],
      targetY = y + baseY[(moveCode - 1) % 8 + 1];

  if((targetX > 127 || targetX < 0 || targetY > 63 || targetY < 0) || // Don't bother if it's out of bounds
     (coords.timesStill > 2 && x == coords.lastX && y == coords.lastY && (moveCode == coords.lastMove || moveCode == coords.last2Move)))
    // Or is doing the same moves and not moving
    return false;

  var targetGrid = grid(targetX, targetY), enemyNear = false, couldStrandEnemy = false,
      eWallDirMove, hasNeighbor = numWalls(targetX, targetY) > 0;

  ebots.forEach(function(ebot){
    // Don't place a wall where an enemy can take it
    if(distanceTo(targetX, targetY, ebot.x, ebot.y) === 1 && !ebot.hasWall && (y != ebot.y || x != ebot.x))
      enemyNear = true;

    // Don't move if you can strand an enemy
    var eWallDir = numWalls(ebot.x, ebot.y, true).indexOf(1) + 1,
        wallX = ebot.x + baseX[eWallDir], wallY = ebot.y + baseY[eWallDir];

    if(!coords.hasWall && numWalls(ebot.x, ebot.y) === 1 &&
       distanceTo(x, y, wallX, wallY) === 1){
      eWallDirMove = dirs[direction(y, wallY) + 1][direction(x, wallX) + 1] + 8;
      couldStrandEnemy = true;
    }
  })

  if(targetX == goal.x && targetY == goal.y && targetGrid === 0){
    targetGrid = 2 // Don't place a wall in the goal
  } else {
    ebots.concat(bots).forEach(function(bot){
      // Ensure target cell doesn't have a bot in it
      if(bot.x == targetX && bot.y == targetY) targetGrid = 2;
    });
  }

  return ((moveCode < 9 && targetGrid !== 1 && hasNeighbor && !couldStrandEnemy) || // Move
          (moveCode > 8 && moveCode < 17 && targetGrid === 1 && !coords.hasWall && (!couldStrandEnemy || (couldStrandEnemy && eWallDirMove == moveCode))) || // Grab
          (moveCode > 16 && targetGrid === 0 && coords.hasWall && !enemyNear)) // Place
}

var goalClosest = {dist: Infinity}, rescuers = {};
bots.forEach(function(bot, index){

  // Check if bot is stranded
  bot.stranded = false;
  if(numWalls(bot.x, bot.y) / 8 == bot.hasWall){
    bot.stranded = true;
    rescuers[index] = -1;
  }
});

bots.forEach(function(bot, index){
  if(!bot.stranded){
    // Find which bot is closest to the goal
    var goalDist = distanceTo(bot.x, bot.y, goal.x, goal.y);

    if(goalDist < goalClosest.dist){
      goalClosest.dist = goalDist;
      goalClosest.index = index;
    }
  }
});

bots.forEach(function(bot, index){
  var destination = {
    x: 14 + (index % 4) * 32 + 3 * (index > 3),
    y: index > 3 ? 55 : 27
  }
  if(index == goalClosest.index){
    destination = goal;
  }

  moves[index] = moveTo(bot, destination);

  if(moves[index] == bot.lastMove || moves[index] == bot.last2Move) bot.timesStill++;

  newMem += moves[index].toString(36) +
    bot.lastMove.toString(36) +
    String.fromCharCode(bot.timesStill + 48) +
    String.fromCharCode(bot.x + 187) +
    String.fromCharCode(bot.y + 187);
});

setMem(newMem);

return moves;

व्याख्या

यह निर्धारित करना कि प्रत्येक बॉट के लिए कौन सी चाल है, इसे दो मुख्य कार्यों में विभाजित किया जा सकता है: पता लगाना कि कहां जाना है और वहां कैसे जाना है।

कहाँ जाना है

यह पता लगाने का मूल कार्य है कि कहाँ जाना आसान है: यदि आप निकटतम हैं, तो लक्ष्य की ओर बढ़ें, या अन्यथा अपने आप को टीम के साथियों से दूर रखने की कोशिश करें। यह पहले प्रत्येक बॉट के माध्यम से जाता है और निर्धारित करता है कि क्या यह फंसे हुए है (अर्थात इसके आस-पास कोई ब्लॉक नहीं है और दीवार पकड़ नहीं है, या यह दीवारों से घिरा हुआ है और दीवार पकड़ता है)। यह फिर बॉट्स के माध्यम से लूप करता है ताकि लक्ष्य के करीब गैर-फंसे हुए बॉट को ढूंढ सके। अन्य सभी बॉट को ब्लॉक की सतह पर नीचे की पंक्ति ( y=55) और शीर्ष पंक्ति के साथ फैलाया जा रहा है y=27। एक बार जब यह पता चल जाता है कि उसे कहां जाना है, तो वह इसे बंद कर देता moveToहै।

वहाँ कैसे पहुंचें

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

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

मेमोरी स्ट्रिंग

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

उदाहरण के लिए, मान लें कि किसी बॉट ने 12इस मोड़ पर दीवार को अपनी बाईं ओर (कोड ) पकड़ लिया , इसे 20अपने पिछले मोड़ में बाईं ओर (कोड ) में बदल दिया, और पिछले घुमावों के लिए निर्देशांक ( 107, 3) पर रहा 16है। इस उदाहरण के लिए मेमोरी स्ट्रिंग निम्नानुसार एन्कोडेड होगी:

  • ck: दो-अंकीय संख्याओं को एक अक्षर बनाने के लिए दो नवीनतम क्रिया कोडों को base36 में बदल दिया जाता है।
  • @: जितनी बार भी इसे अभी भी ASCII वर्ण के रूप में दर्शाया गया है उस कोड + 48 के साथ यह छापने योग्य वर्णों को छोड़ने के लिए है और इसलिए पहले नौ बार अभी भी वास्तविक संख्या ( String.fromCharCode(0 + 48)0) दिखाता है ।
  • Ħ¾: X और y निर्देशांक को उस मान के साथ चरित्र के रूप में भी दर्शाया जाता है, इस बार समस्याग्रस्त पात्रों से बचने के लिए 187 के कुछ हद तक मनमाने मूल्य द्वारा ऑफसेट किया जाता है।

खेल के दौरान एक विशिष्ट मेमोरी स्ट्रिंग 53äÇØb7¼ðÌ00ßĉÖ7m±ĪÚ00ĝÌò00Ĝìò00ĖČò00ĈĬò, आठ बॉट्स में से प्रत्येक के लिए पांच वर्णों के समूह के साथ हो सकती है ।


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

@trichoplax मैं इसकी कल्पना करता हूं क्योंकि पी 1 पी 2 से पहले चलता है, इसलिए पी 1 पी 2 को फंसेगा इससे पहले कि वह ऐसा कर सके।
निन्जाबियरमॉन्की

4
चुनौती खत्म हो गई है और परिणाम सामने हैं ! 30 राउंड के बाद, ब्लैक नाइट में 204 जीत दर्ज की गई, और अगली सर्वश्रेष्ठ प्रविष्टि, सीकर्स , केवल 147 रही। बधाई हो NinjaBearMonkey ! आप विशिष्ट चुनौती रास्ते पर है।
केल्विन के शौक

बिल्कुल निंजा! धन्यवाद
edc65

12

चौकियों

8 बॉट्स प्रत्येक में 32 वर्ग के हिसाब से 32 लेते हैं और उसके केंद्र तक जाते हैं (मैं केंद्रों को थोड़ा सा भर देता हूं अन्यथा वे जोड़ी बनाते हैं और उनके बीच एक दीवार ब्लॉक के साथ लंबवत यात्रा करते हैं, इसलिए उनमें से एक फंसे हो जाता है)।

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

यह अभी भी अपने लक्ष्य (लक्ष्य या केंद्र) तक पहुंचने की बेसलाइन विधि का उपयोग करता है ताकि तिरछे तरीके से न चले। बस एक प्रारंभिक बिंदु ...

var encodeAction = function(type, dx, dy) {
    var d
    if (dx === -1 && dy === -1) d = 1
    else if (dx === 0 && dy === -1) d = 2
    else if (dx === 1 && dy === -1) d = 3
    else if (dx === -1 && dy === 0) d = 4
    else if (dx === 1 && dy === 0) d = 5
    else if (dx === -1 && dy === 1) d = 6
    else if (dx === 0 && dy === 1) d = 7
    else if (dx === 1 && dy === 1) d = 8
    else return 0
    return 8 * type + d
}

var getNeighborCell = function(x, y, wallState) {
    if (x > 0 && y > 0 && grid(x - 1, y - 1) === wallState) return { x: x - 1, y: y - 1 }
    if (y > 0 && grid(x, y - 1) === wallState) return { x: x, y: y - 1 }
    if (x < 127 && y > 0 && grid(x + 1, y - 1) === wallState) return { x: x + 1, y: y - 1 }
    if (x > 0 && grid(x - 1, y) === wallState) return { x: x - 1, y: y }
    if (x < 127 && grid(x + 1, y) === wallState) return { x: x + 1, y: y }
    if (x > 0 && y < 63 && grid(x - 1, y + 1) === wallState) return { x: x - 1, y: y + 1 }
    if (y < 63 && grid(x, y + 1) === wallState) return { x: x, y: y + 1 }
    if (x < 127 && y < 63 && grid(x + 1, y + 1) === wallState) return { x: x + 1, y: y + 1 }
    return null
}

var moveBot = function(n) {
    var assignedX = (n % 4) * 32 + 14 + Math.floor(n/4) * 4
    var assignedY = (Math.floor(n / 4)) * 32 + 16
    if (Math.abs(goal.x - assignedX) < 33 && Math.abs(goal.y - assignedY) < 33) {
        assignedX = goal.x
        assignedY = goal.y
    }
    var b = bots[n], moveX = b.x !== assignedX, x = b.x, y = b.y, type
    if (moveX) {
        x += b.x < assignedX ? 1 : -1
    } else {
        y += b.y < assignedY ? 1 : -1
    }
    if (grid(x, y) === 1) {
        if (b.hasWall) {
            type = 2 //place
            var c = getNeighborCell(b.x, b.y, 0)
            if (!c) { //stuck holding wall with walls all around
                return 0
            }
            x = c.x
            y = c.y
        } else {
            type = 1 //grab
        }
    } else if (grid(x, y) === 0) {
        if (getNeighborCell(x, y, 1)) {
            type = 0 //move
        } else {
            if (b.hasWall) {
                type = 2 //place
                if (moveX) {
                    y += y > 0 ? -1 : 1
                } else {
                    x += x > 0 ? -1 : 1
                }
            } else {
                type = 1 //grab
                var c = getNeighborCell(b.x, b.y, 1)
                if (!c) { //stuck without wall in midair
                    return 0
                }
                x = c.x
                y = c.y
            }
        }
    } else {
        return 0 //should never get here
    }
    return encodeAction(type, x - b.x, y - b.y)
}

var actions = []
for (var i = 0; i < 8; i++) {
    actions[i] = moveBot(i)
}

return actions

1
मुझे पता है कि यह सिर्फ शुरुआत है, लेकिन एक बात मैंने आधार रेखा के साथ (असमान) लड़ाई को देखते हुए देखी: यदि लक्ष्य कई केंद्रों की पहुंच के भीतर है, तो वे सभी लक्ष्य की ओर भागते हैं। बेहतर हो सकता है कि केवल निकटतम व्यक्ति को ही चुनें, और दूसरों को "आदर्श" स्थिति पर रखें? देखने में मज़ा, btw।
रेटो कोराडी

धन्यवाद! हाँ, यह निश्चित रूप से एक सुधार होगा। दूसरों के बारे में सोचने के लिए भी लंबी सूची है, और उपयोग करने के लिए विभिन्न रणनीतियों की एक किस्म है। मैं यह देखने के लिए उत्सुक हूं कि अन्य लोग किस रणनीति का चयन करते हैं और वे कैसे बातचीत करते हैं ...
ट्रिकोप्लाक्स

9

बेसलाइन

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

यहां किसी भी कोड की नकल की जा सकती है और उसका उपयोग किसी अन्य उत्तर में किया जा सकता है, किसी भी प्रकार की कोई आवश्यकता नहीं है।

var encodeAction = function(type, dx, dy) {
    var d
    if (dx === -1 && dy === -1) d = 1
    else if (dx === 0 && dy === -1) d = 2
    else if (dx === 1 && dy === -1) d = 3
    else if (dx === -1 && dy === 0) d = 4
    else if (dx === 1 && dy === 0) d = 5
    else if (dx === -1 && dy === 1) d = 6
    else if (dx === 0 && dy === 1) d = 7
    else if (dx === 1 && dy === 1) d = 8
    else return 0
    return 8 * type + d
}

var getNeighborCell = function(x, y, wallState) {
    if (x > 0 && y > 0 && grid(x - 1, y - 1) === wallState) return { x: x - 1, y: y - 1 }
    if (y > 0 && grid(x, y - 1) === wallState) return { x: x, y: y - 1 }
    if (x < 127 && y > 0 && grid(x + 1, y - 1) === wallState) return { x: x + 1, y: y - 1 }
    if (x > 0 && grid(x - 1, y) === wallState) return { x: x - 1, y: y }
    if (x < 127 && grid(x + 1, y) === wallState) return { x: x + 1, y: y }
    if (x > 0 && y < 63 && grid(x - 1, y + 1) === wallState) return { x: x - 1, y: y + 1 }
    if (y < 63 && grid(x, y + 1) === wallState) return { x: x, y: y + 1 }
    if (x < 127 && y < 63 && grid(x + 1, y + 1) === wallState) return { x: x + 1, y: y + 1 }
    return null
}

var moveBot = function(n) {
    var b = bots[n], moveX = b.x !== goal.x, x = b.x, y = b.y, type
    if (moveX) {
        x += b.x < goal.x ? 1 : -1
    } else {
        y += b.y < goal.y ? 1 : -1
    }
    if (grid(x, y) === 1) {
        if (b.hasWall) {
            type = 2 //place
            var c = getNeighborCell(b.x, b.y, 0)
            if (!c) { //stuck holding wall with walls all around
                return 0
            }
            x = c.x
            y = c.y
        } else {
            type = 1 //grab
        }
    } else if (grid(x, y) === 0) {
        if (getNeighborCell(x, y, 1)) {
            type = 0 //move
        } else {
            if (b.hasWall) {
                type = 2 //place
                if (moveX) {
                    y += y > 0 ? -1 : 1
                } else {
                    x += x > 0 ? -1 : 1
                }
            } else {
                type = 1 //grab
                var c = getNeighborCell(b.x, b.y, 1)
                if (!c) { //stuck without wall in midair
                    return 0
                }
                x = c.x
                y = c.y
            }
        }
    } else {
        return 0 //should never get here
    }
    return encodeAction(type, x - b.x, y - b.y)
}

var actions = []
for (var i = 0; i < 8; i++) {
    actions[i] = moveBot(i)
}

return actions

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

प्रत्येक बॉट का मूवमेंट एल्गोरिथ्म इस प्रकार है:

If my X is not equal to the goal's X
    P = position to my left or right that is closer to the goal  
    Make a note that I'm trying to move horizontal  
Else  
    P = position above or below me that is closer to the goal  
    Make a note that I'm trying to move vertical  

If P is a wall  
    If I'm holding a wall  
        Place my wall in any neighboring air cell  
    Else  
        Grab the wall at P  
Else if P is air  
    If P has a wall neighboring it (i.e. if I can move to P)  
        Move to P  
    Else  
        If I'm holding a wall  
            If I'm trying to move horizontal  
                Place my wall above or below P  
            Else if I'm trying to move vertical  
                Place my wall to the left or right of P  
        Else  
            Grab wall from any neighboring wall cell   

6

टीम के खिलाड़ी

फिलहाल, यह सबमिशन बिल्कुल सही नहीं है। इसकी आउटपोस्ट जैसी ही रणनीति है, लेकिन केवल 6 बॉट "हवा में" हैं। अन्य 2 बॉट चोरी होने पर उन्हें दीवारों के साथ आपूर्ति करते हैं। संपादित करें: समर्थक बॉट अब बेहतर प्रदर्शन करते हैं।

var outside = function(x,y) {
    return x < 0 || x > 127 || y < 0 || y > 127
}

var distance = function(x1, y1, x2, y2){
  return Math.sqrt(Math.pow(x1-x2, 2) + Math.pow(y1-y2, 2));
}

var isStuck = function(bot) {
    if (bot.hasWall) {
        for (var i=-1; i<=1; i++) {
            for (var j=-1; j<=1; j++) {
                if ((i != 0 || j != 0) && grid(bot.x+i,bot.y+j) == 0 && !outside(bot.x+i,bot.y+j))
                    return false
            }
        }
        return true
    }
    for (var i=-1; i<=1; i++) {
        for (var j=-1; j<=1; j++) {
            if (grid(bot.x+i, bot.y+j) == 1)
                return false
        }
    }
    return true
}

var isPlayer = function(x,y) {
    for (var i = 0; i < bots.length; i++) {
        if (bots[i].x == x && bots[i].y == y)
            return true
    }
    for (var i = 0; i < ebots.length; i++) {
        if (ebots[i].x == x && ebots[i].y == y)
            return true
    }
    return false
}

var encodeAction = function(type, dx, dy) {
    var d
    if (dx === -1 && dy === -1) d = 1
    else if (dx === 0 && dy === -1) d = 2
    else if (dx === 1 && dy === -1) d = 3
    else if (dx === -1 && dy === 0) d = 4
    else if (dx === 1 && dy === 0) d = 5
    else if (dx === -1 && dy === 1) d = 6
    else if (dx === 0 && dy === 1) d = 7
    else if (dx === 1 && dy === 1) d = 8
    else return 0
    return 8 * type + d
}

var surrounding = function(x,y) {
    var cell = {hasStone:false, cells: []}
    for (var i=-1; i<=1; i++) {
        for(var j=-1; j<=1; j++) {
            if ((i != 0 || j != 0) && !outside(x+i,y+j)) {
                cell.cells.push({x:x+i, y:y+j})
                if (grid(x+i,y+j) == 1) {
                    cell.hasStone = true
                }
            }
        }
    }
    return cell
}


var hunt = function(i, destination) {
    destination = destination || {x: 31+((i-2)%3)*32, y: 20+((i-2)%2)*21}, bot = bots[i]
    if (i < 5 && i > 1) {
        destination.x -= 2
    }
    if (bot.isStuck) {
        return 0
    }
    if ((p1 && destination.x >= move + i) || (!p1 && 127 - destination.x > move - i)) {
        destination.y = bot.y
    }
    if (i == bestBotId && move > 50) {
        destination.x = goal.x
        destination.y = goal.y
    }
    var dx = destination.x > bot.x ? 1 : destination.x == bot.x ? 0 : -1, newX = bot.x + dx
    var dy = destination.y > bot.y ? 1 : destination.y == bot.y ? 0 : -1, newY = bot.y + dy
    var surr = surrounding(newX, newY), botSurr = surrounding(bot.x, bot.y)
    if (grid(newX, newY) == 0) {
        if (surr.hasStone) {
            return encodeAction(0, dx, dy)
        } else {
            if (bot.hasWall) {
                for (var i=0; i<surr.cells.length; i++) {
                    var cell = surr.cells[i];
                    if (Math.abs(cell.x - bot.x) <= 1 && Math.abs(cell.y - bot.y) <= 1 && grid(cell.x, cell.y) == 0 && !isPlayer(cell.x, cell.y)) {
                        return encodeAction(2, cell.x - bot.x, cell.y - bot.y)
                    }
                }
            } else {
                if (bot.walls.length == 1) {
                    return encodeAction(1, bot.walls[0].x - bot.x, bot.walls[0].y - bot.y)
                } else {
                    for (var i=0; i<bot.walls.length; i++) {
                        var wall = bot.walls[i], canUseWall = true
                        for (var j=0; j<bots.length; j++) {
                            if (bots[j].walls.length == 1 && bots[j].walls[0].x == wall.x && bots[j].walls[0].y == wall.y) {
                                canUseWall = false
                            }
                        }
                        if (canUseWall) {
                            return encodeAction(1, wall.x - bot.x, wall.y - bot.y)
                        }
                    }
                }
            }
        }
    } else {
        if (bot.hasWall) {
            for (var i=0; i<botSurr.cells.length; i++) {
                var cell = botSurr.cells[i];
                if (grid(cell.x, cell.y) == 0 && !isPlayer(cell.x, cell.y) && !outside(cell.x, cell.y)) {
                    return encodeAction(2, cell.x - bot.x, cell.y - bot.y)
                }
            }
        } else {
            return encodeAction(1, dx, dy)
        }
    }
    return 0 //hopefully never happens
}

var help = function(i) {
    if (bots[i].isStuck) {
        return 0
    }
    var bot = bots[i], destination = helpDestinations[i]
    if (destination.stuckBot == -1) {
        if (bot.walls.length >= 2 || (bot.hasWall && bot.walls.length == 1)) {
            var stuckId = -1
            for (var j = 0; j < bots.length; j++) {
                if (j != helpDestinations[(i+1)%2].stuckBot && bots[j].isStuck)
                    stuckId = j
            }
            if (stuckId != -1) {
                destination.stuckBot = stuckId
                destination.x = bots[stuckId].x
                destination.y = bots[stuckId].y
                return 0
            } else {
                return hunt(i, destination)
            }
        } else if (bot.x == destination.x && bot.y == destination.y) {
            if (move % 2 == 0)
                destination.y += 1
            else
                destination.x -= 1
            return hunt(i, destination)
        } else {
            return hunt(i, destination)
        }
    } else if (bots[destination.stuckBot].isStuck) {
        if (bot.walls.length < 2 && !(bot.hasWall && bot.walls.length == 1)) {
            destination.stuckBot = -1
            destination.x = i == 0 ? 42 : 85
            destination.y = 55
            return hunt(i, destination)
        }
        var dx = destination.x > bot.x ? 1 : destination.x == bot.x ? 0 : -1, newX = bot.x + dx
        var dy = destination.y > bot.y ? 1 : destination.y == bot.y ? 0 : -1, newY = bot.y + dy
        var surr = surrounding(newX, newY), botSurr = surrounding(bot.x, bot.y), surrWalls = 0
        for (var i = 0; i < surr.cells.length; i++) {
            var cell = surr.cells[i]
            if (grid(cell.x,cell.y) == 1)
                surrWalls++
        }
        if (grid(newX, newY) == 0) {
            if (surrWalls >= 2 || (surr.hasWall && bot.hasWall)) {
                return encodeAction(0, dx, dy)
            } else {
                if (bot.hasWall) {
                    for (var i=0; i<surr.cells.length; i++) {
                        var cell = surr.cells[i];
                        if (Math.abs(cell.x - bot.x) <= 1 && Math.abs(cell.y - bot.y) <= 1 && grid(cell.x, cell.y) == 0 && !isPlayer(cell.x, cell.y)) {
                            return encodeAction(2, cell.x - bot.x, cell.y - bot.y)
                        }
                    }
                } else {
                    if (bot.walls.length == 1) {
                        return encodeAction(1, bot.walls[0].x - bot.x, bot.walls[0].y - bot.y)
                    } else {
                        for (var i=0; i<bot.walls.length; i++) {
                            var wall = bot.walls[i], canUseWall = true
                            for (var j=0; j<bots.length; j++) {
                                if (bots[j].walls.length == 1 && bots[j].walls[0].x == wall.x && bots[j].walls[0].y == wall.y) {
                                    canUseWall = false
                                }
                            }
                            for (var j=0; j<surr.cells.length; j++) {
                                if (surr.cells[j].x == wall.x && surr.cells[j].y == wall.y)
                                    canUseWall = false
                            }
                            if (canUseWall) {
                                return encodeAction(1, wall.x - bot.x, wall.y - bot.y)
                            }
                        }
                    }
                }
            }
        } else {
            if (bot.hasWall) {
                for (var i=0; i<botSurr.cells.length; i++) {
                    var cell = botSurr.cells[i];
                    if (grid(cell.x, cell.y) == 0 && !isPlayer(cell.x, cell.y)) {
                        return encodeAction(2, cell.x - bot.x, cell.y - bot.y)
                    }
                }
            } else {
                return encodeAction(1, dx, dy)
            }
        }
    } else {
        destination.stuckBot = -1
        destination.x = i == 0 ? 42 : 85
        destination.y = 55
        return hunt(i, destination)
    }
    return 0 //hopefully never happens
}

var moves = new Array(8)    
var mem = getMem(), helpDestinations = []
if (mem.length == 0) {
    mem = "42,55,-1 85,55,-1"
}
mem = mem.split(" ")
for (var i = 0; i < mem.length; i++) {
    var cell = mem[i].split(",")
    helpDestinations.push({x: parseInt(cell[0]), y: parseInt(cell[1]), stuckBot: parseInt(cell[2])})
}

for (var i = 0; i < 8; i++) {
    var bot = bots[i]
    var surr = surrounding(bot.x, bot.y)
    bot.walls = []
    for (var j = 0; j < surr.cells.length; j++) {
        if (grid(surr.cells[j].x, surr.cells[j].y) == 1) {
            bot.walls.push(surr.cells[j])
        }
    }
}

bots.forEach(function(bot, index) {
    if(isStuck(bot)) {
        bot.isStuck = true
    }
})

var bestDistance = 1000
var bestBotId = -1
for (var i=2; i<8; i++) {
    var dist = distance(bots[i].x, bots[i].y, goal.x, goal.y)
    if (dist < bestDistance && !bots[i].isStuck) {
        bestDistance = dist
        bestBotId = i
    }
}

for (var i=0; i<8; i++) {
    if (i < 2) {
        moves[i] = help(i)
    } else {
        moves[i] = hunt(i)  
    }
}

setMem(helpDestinations[0].x + "," + helpDestinations[0].y + "," + helpDestinations[0].stuckBot + " " + helpDestinations[1].x + "," + helpDestinations[1].y + "," + helpDestinations[1].stuckBot)

return moves

समर्थक विचार (अच्छा) को लागू करना मुश्किल लगता है।
edc65

@ edc65 यह मूल रूप से केवल एक के बजाय 2 दीवारों के साथ घूम रहा है। लेकिन दो समर्थन बॉट्स और नई दीवारों को खोजने के बीच संचार को लागू करना मुश्किल था :)
कॉमनग्यू

6

चाहने वालों

कार्य प्रगति पर रहेगा। मेरे पास कई विचार हैं, लेकिन उनमें से लगभग कोई भी काम नहीं करता है।

सब से ऊपर, असफल कार्यों के साथ बड़ी समस्या। हल किया!

var action=[], myGrid=[], goalSort=[], i, j, curBot, curAction, goalSeek;

var check = function(x,y) {
  return (myGrid[[x,y]] || (myGrid[[x,y]] = grid(x,y)))|0;
};

var setGrid = function(x,y,v) {
  myGrid[[x,y]] = v + '';
};

var orGrid = function(x,y,v) {
  myGrid[[x,y]] |= v;
};

var encodeDir = function(dx, dy) {
    return dx < 0 && dy < 0 ? 1
    : dx === 0 && dy < 0 ? 2
    : dx > 0 && dy < 0 ? 3
    : dx < 0 && dy === 0 ? 4
    : dx > 0 && dy === 0 ? 5
    : dx < 0 && dy > 0 ? 6
    : dx === 0 && dy > 0 ? 7
    : dx > 0 && dy > 0 ? 8
    : 0;
};

var distance = function(p1, p2) {
  return Math.max(Math.abs(p1.x-p2.x),Math.abs(p1.y-p2.y));
};

var cellNearWall = function(x,y)
{
  var r = check(x,y) == 1 ? 0
  : check(x-1,y-1) == 1 ? 1
  : check(x,y-1) == 1 ? 2
  : check(x+1,y-1) == 1 ? 3
  : check(x-1,y) == 1 ? 4
  : check(x+1,y) == 1 ? 5
  : check(x-1,y+1) == 1 ? 6
  : check(x,y+1) == 1 ? 7
  : check(x+1,y+1) == 1 ? 8
  : 0;
  return r;
};

var cellNearBot = function(x,y,m)
{
  return check(x-1,y-1) & m ? 1
  : check(x,y-1) & m ? 2
  : check(x+1,y-1) & m ? 3
  : check(x-1,y) & m ? 4
  : check(x+1,y) & m ? 5
  : check(x-1,y+1) & m ? 6
  : check(x,y+1) & m ? 7
  : check(x+1,y+1) & m ? 8
  : 0;
};


var tryGrabWall = function(x, y)
{
  var dx, dy, r = 8;
  for(dy = -1; dy < 2; ++dy)
  {
    for(dx = -1; dx < 2; ++dx)
    {
      if (dx|dy)
      {
        ++r;
        if (check(x+dx, y+dy) == 1)
        {
          setGrid(x+dx, y+dy, 0); // remember that the wall is not there anymore
          return r;
        }
      }
    }
  }
  return 0;
};

var tryDropWall= function(x, y)
{
  var dx, dy, r = 16;
  for(dy = -1; dy < 2; ++dy)
  {
    for(dx = -1; dx < 2; ++dx)
    {
      if (dx|dy)
      {
        ++r;
        if (x+dx>=0 & x+dx < 128 & y+dy >= 0 & y+dy < 64 && check(x+dx, y+dy) == 0)
        {
          setGrid(x+dx, y+dy, 1); // remember that the wall is there 
          return r;
        }
      }
    }
  }
  return 0;
};


var approach = function(bot, target)
{
  var dx, dy, tx, ty, r = 0, wallPos;

  var checkDrop = function(dx,dy)
  {
    var x = bot.x+dx, y = bot.y+dy;
    if (check(x,y) == 0 && cellNearBot(x,y,8) == 0)
    {
      setGrid(x, y, 1);
      return 16 + encodeDir(dx, dy);
    }
  };

  dy = target.y - bot.y;
  dy = dy < 0 ? -1 : dy > 0 ? 1 : 0;
  dx = target.x - bot.x;
  dx = dx < 0 ? -1 : dx > 0 ? 1 : 0;
  tx = bot.x+dx;
  ty = bot.y+dy;

  if ((dx|dy) === 0)
  {
    if (!bot.hasWall) {
      return tryGrabWall(bot.x, bot.y);
    }
    return 0;
  }


  if (cellNearWall(tx,ty))
  {
    setGrid(tx, ty, 2);
    return encodeDir(dx, dy);
  }

  if (dx === 0)
  {
    if (cellNearWall(bot.x-1,ty))
    {
      setGrid(bot.x-1, ty, 2);
      return encodeDir(-1, dy);
    }
    if (cellNearWall(bot.x+1,ty))
    {
      setGrid(bot.x+1, ty, 2);
      return encodeDir(1, dy);
    }
    if (bot.hasWall) 
    {
      if (wallPos = checkDrop(1,dy)) { return wallPos; }
      if (wallPos = checkDrop(-1,dy)) { return wallPos; }
      if (wallPos = checkDrop(1,0)) { return wallPos; }
      if (wallPos = checkDrop(-1,0)) { return wallPos; }
    }
  }
  else if (dy === 0) 
  {
    if (cellNearWall(tx,bot.y-1))
    {
      setGrid(tx, bot.y-1, 2);
      return encodeDir(dx, -1);
    }
    if (cellNearWall(tx,bot.y+1))
    {
      setGrid(tx, bot.y+1, 2);
      return encodeDir(dx, 1);
    }
    if (bot.hasWall) 
    {
      if (wallPos = checkDrop(dx,1)) { return wallPos; }
      if (wallPos = checkDrop(dx,-1)) { return wallPos; }
      if (wallPos = checkDrop(0,1)) { return wallPos; }
      if (wallPos = checkDrop(0,-1)) { return wallPos; }
    }
  }
  else
  {
    if (cellNearWall(tx,bot.y))
    {
      setGrid(tx, bot.y, 2);
      return encodeDir(dx, 0);
    }
    if (cellNearWall(bot.x,ty))
    {
      setGrid(bot.x, ty, 2);
      return encodeDir(0,dy);
    }
    if (bot.hasWall) {
      if (wallPos = checkDrop(dx,0)) { return wallPos; }
      if (wallPos = checkDrop(0,dy)) { return wallPos; }
      if (wallPos = checkDrop(dx,dy)) { return wallPos; }
    }
  }

  if (!bot.hasWall)
  {
  if (check(tx, ty) == 1)
  {
      setGrid(tx, ty, 0); // remember that the wall is not there anymore
      return 8 + encodeDir(dx, dy);
    };
    return tryGrabWall(bot.x, bot.y);
  }
  else
  {
    return tryDropWall(bot.x, bot.y);
  }
};

for (i=0; curBot=ebots[i]; i++)
{
  setGrid(curBot.x, curBot.y, curBot.hasWall ? 4 : 8);
}

var goalDistance=[]

for (i=0; curBot=bots[i]; i++)
{
  orGrid(curBot.x, curBot.y, 2);
  goalDistance[i] = distance(curBot, goal);
}
var sorted = goalDistance.slice().sort(function(a,b){return a-b})
var ranks = goalDistance.slice().map(function(v){ return sorted.indexOf(v)});

var tt = p1 
? [ { x:32, y:20 },{ x:32, y:55 },{ x:64, y:20 },{ x:64, y:55 },
   { x:96, y:20 },{ x:96, y:55 },{ x:16, y:30 },{ x:112, y:30 }]
: [ { x:96, y:20 },{ x:96, y:55 },{ x:64, y:20 },{ x:64, y:55 },
   { x:32, y:20 },{ x:32, y:55 },{ x:112, y:30 },{ x:16, y:30 }]

var goalSeek = 3;

for (i=0; curBot=bots[i]; i++)
{
  if (ranks[i] < goalSeek)
  {
    curAction = approach(curBot, goal);
    if (curAction == 0) goalSeek += 1;
  }
  else
    curAction = approach(curBot, tt[i]);

  action[i] = curAction;
}

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