यह चुनौती @HelkaHomba की उत्कृष्ट चुनौती रेड बनाम ब्लू - पिक्सेल टीम बैटलबोट्स से प्रेरित थी । यह चुनौती शायद सबसे अच्छी थी जिसे मैंने इस साइट पर देखा था। कभी।

_{मेरी चुनौती अभी भी बहुत अलग है, लेकिन @HelkaHomba प्रेरणा के लिए श्रेय की हकदार है।}

अवलोकन

यह एक टीम का राजा है, जहां आपकी टीम आपकी टीम के सभी खिलाड़ियों को जीवित करके जीतती है। दूसरे शब्दों में, अंतिम टीम खड़ी जीत है। ड्रॉ फिर से कराया जाएगा।

आप एक बोर्ड पर हैं। आप पहले राउंड पर अपनी स्थिति जानते हैं (टिक 0)। आप यह भी जानते हैं कि आपके आसपास के क्षेत्र में कौन है:

इस मामले में, आप अकेले हैं (या तो आप सोचते हैं) आपके आसपास कोई नहीं है। आप अपने ontickहैंडलर को पहले तर्क में आसपास की वस्तुएँ देख सकते हैं । एपीआई के बारे में बाद में।

तुम्हारी टीम

आपकी टीम आपकी उपयोगकर्ता आईडी द्वारा निर्धारित होती है। यह पता लगाने के लिए, अपने प्रोफ़ाइल चित्र पर क्लिक करें:

फिर एड्रेस बार में अपनी यूजर आईडी खोजें:

यदि यह विषम है, तो आप ब्लू टीम पर हैं।

यदि यह सम है, तो आप रेड टीम पर हैं।

_{आप हाथ से तैयार हलकों के लिए स्वागत करते हैं।}

आपका (बॉट का) नाम

आपके बॉट का नाम आपकी टीम के पहले अक्षर ("r" या "b") से शुरू होता है। यह रेगेक्स से मेल खाना चाहिए /^(r|b)[A-Za-z_-]$/। इसके अलावा, आप अपने बॉट का नाम चुन सकते हैं। कृपया पहले से मौजूद एक का उपयोग न करें।

शुरुआत में

लाल खिलाड़ी नक्शे के शीर्ष के पास शुरू करेंगे, और नीले तल के पास शुरू होंगे। आपको फ़ंक्शन के environmentलिए पैरामीटर में पहले टिक (टर्न) पर विशेष जानकारी दी जाती है ontick। मैं भंडारण की सलाह देता हूं। जानकारी के लिए एपीआई देखें।

अपनी बारी पर

टर्न ऑर्डर शुरू में यादृच्छिक होता है, लेकिन फिर वही रहता है।

क्रियाओं को चालू करें

आप प्रति बार केवल एक क्रिया कर सकते हैं।

चाल

जब आप स्थानांतरित करना चाहेंगे, तो आप this.move(num)एपीआई में कॉल करेंगे । numवह सेल है जिसे आप यहां ले जाना चाहते हैं:

उन संख्याओं के सापेक्ष स्थान जिन्हें आप स्थानांतरित कर सकते हैं वे वैश्विक स्थिरांक में संग्रहीत हैं threeByThree:

[
    [0, 1, 2],
    [3, undefined, 4],
    [5, 6, 7]
]

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

घुमाएँ

घुमाने के लिए, तुम बुलाओ this.rotate(num)। संख्या वह दिशा है जिसे आप घुमाना चाहते हैं:

रोटेशन निरपेक्ष है।
को मार डालो

यदि कोई अन्य खिलाड़ी (किसी अन्य टीम से) आपके द्वारा सामना की जा रही सेल में है, तो आप this.kill()उन्हें कॉल और मार सकते हैं। अगर वहां कोई नहीं है, या वे आपकी टीम में हैं, तो यह कुछ नहीं करता है। उदाहरण:

यदि आप कर रहे हैं 0, तो आप हरे रंग को मार सकते हैं। यदि आप 1 वर्ष के हो गए हैं, तो आप नीले रंग को मार सकते हैं। यदि आप 2 वर्ष के हो गए हैं, तो आप संतरे को मार सकते हैं। यदि आप 3 वर्ष के हो गए हैं, तो आप पीले रंग को मार सकते हैं।
बम

बमबारी आपके चारों ओर के 9 वर्गों में आप और टीम के साथियों सहित सभी खिलाड़ियों को मार देती है । उदाहरण:

आप कभी ऐसा क्यों करना चाहेंगे? कामिकज़े । यदि आपके आस-पास के 9 कक्षों में आपकी टीम में अधिक खिलाड़ी नहीं हैं, तो आपकी टीम में हैं, आप बमबारी पर विचार कर सकते हैं। (मेरा सुझाव है कि आप पहले अपने साथियों को सूचित करें!)
एक बारूदी सुरंग लगाएं

यह आपकी टीम पर नहीं दूसरों के लिए एक मृत्यु वर्ग बनाता है। जब आप एक लैंड माइन लगाते हैं, तो आप भी आगे बढ़ते हैं ताकि आप उस पर कदम न रखें। आप कहते हैं this.landMine(num)कि संख्या वह वर्ग है जहां आप जाना चाहते हैं। उदाहरण:

फिर आप कॉल करें this.landMine(4):

देखें कि "एम"? यह एक बारूदी सुरंग है। अन्य लोग इसे देख सकते हैं ... अभी के लिए। कोई भी, यहां तक कि जो आपकी टीम में नहीं हैं, वह उस टिक पर एक बारूदी सुरंग देख सकता है। लेकिन उसके बाद टिक खत्म हो गया है, नो-वन, यहां तक कि आप इसे देख भी नहीं सकते। लेकिन जैसे ही कोई दुश्मन उसके ऊपर से गुजरेगा वह फट जाएगा। उदाहरण:

ब्लू अपने लैंडमाइन पर चला गया, और बूम! आपको बस एक और मार मिली।

आपको मिलने वाली प्रत्येक 2 हत्याओं के लिए (प्रत्यक्ष हत्या या भूमि खानों से), आपको जगह पाने के लिए 1 अतिरिक्त बारूदी सुरंग मिल जाती है। तुम भी शुरू में एक हो जाओ।
गड्ढा करना

जब आप खुदाई करते हैं, तो आप अपने आसपास केंद्रित 5x5 क्षेत्र में बारूदी सुरंगों की तलाश करते हैं। इसमें बॉट की टीम को नहीं दिखाया गया है जिसने बारूदी सुरंग लगा रखी है। (याद रखें कि आप अपनी टीम में किसी व्यक्ति द्वारा रखी गई बारूदी सुरंग से नहीं मारे जा सकते।) उदाहरण के लिए, यदि यह आपके आसपास ग्रिड था:

फिर वापसी का मान this.dig()होगा:

[undefined,undefined,undefined,true,undefined,
undefined,undefined,undefined,undefined,undefined,
undefined,undefined,undefined,undefined,
undefined,undefined,true,undefined,undefined,
true,undefined,undefined,undefined,undefined]

एरे इंडेक्स शीर्ष बाएं से शुरू होने से हैं, दाएं से नीचे जा रहे हैं, अपने आप से शामिल नहीं हैं:

कुल 23 हैं, और उनके सापेक्ष स्थान वैश्विक स्थिरांक में संग्रहीत हैं fiveByFive:

[
    [0, 1, 2, 3, 4],
    [5, 6, 7, 8, 9],
    [10, 11, undefined, 12, 13],
    [14, 15, 16, 17, 18],
    [19, 20, 21, 22, 23]
]

ध्यान दें कि खुदाई पिछली टिकों पर रखी गई खानों को प्रकट करती है, इसके विपरीत aroundMe।

संचार

जब आप किसी से बात करना चाहते हैं, तो आप फोन करते हैं this.sendMessage(recipients, team, data)। डेटा कुछ भी हो सकता है जिसे आप चाहते हैं, और आप इसे किसी को भी भेज सकते हैं, यहां तक कि अन्य टीमों के खिलाड़ी भी। इसका उपयोग खराब-प्रोग्राम किए गए बॉट्स को ट्रिक करने के लिए किया जा सकता है, लेकिन सभी खिलाड़ी देख सकते हैं कि किसने संदेश भेजा है और वे किस टीम में हैं।

उदाहरण:

"रेडिसबेस्ट" नामक एक बॉट में कुछ भेजें:

this.sendMessage("redisbest", undefined, "Hi!");

"रेडिसबेस्ट" और "ब्लूस्कूल" नामक बॉट में कुछ भेजें:

this.sendMessage(["redisbest", "blueiscool"], undefined, {hello: "there"});

पूरी रेड टीम को कुछ भेजें

this.sendMessage(undefined, "red", {hello: "red"});

सभी को कुछ न कुछ भेजें

this.sendMessage(undefined, "*", {hello: "everyone"});

पूरी रेड टीम और "ब्लूस्कूल" नामक बॉट को कुछ भेजें:

this.sendMessage("blueiscool", "red", {hello: "bots"});

एपीआई

आपके कोड में फ़ंक्शन के लिए एक कॉल शामिल होना चाहिए `createBot`। और कुछ नहीं। नमूना कोड:

createBot({
    ontick: function(environment) {
        return new Promise((resolve, reject)=>{
            this.move(0);//example
            resolve();//please call this when you are done
        });
    },
    onmessage: function(data, from, fromBot) {
        console.log("onMessage: " + this.name + " from " + this.team + " got message ", data, " from " + from + ", on team " + fromTeam);
        this.sendMessage(["bot", "otherbot"], "team", "some data");
    },
    team: "red",//your team
    name: "rmyteamname",//team name must begin with the first letter of your team's name
    onkill: function(){
        //say goodbye
    }
});

(आप इसे कॉपी-पेस्ट करने के लिए स्वतंत्र हैं। बस इसे अपनी टीम के लिए संशोधित करें, आदि)

तरीके

ontick(environment)
जब आपकी बारी है तो फोन किया। Promise1 सेकंड या उससे कम समय में हल करने वाले को वापस करना चाहिए या इसे अनदेखा कर दिया जाएगा। यह प्रदर्शन कारणों के लिए है और टैब हैंग न होने का अच्छा दुष्प्रभाव है।

this (जब ontick में)
- landMines आपने कितनी लैंड माइंस छोड़ी हैं। आपके पास जितनी अधिक हत्याएं होंगी, उतनी अधिक भूमि की खदानें होंगी। आपके द्वारा मारे गए प्रत्येक 2 बॉट के लिए, आपको 1 और बारूदी सुरंग मिलती है। आपको भी शुरू करने के लिए 1 मिलता है।
- direction आप जिस दिशा का सामना कर रहे हैं।
- storage भंडारण जो कॉल onTickऔर के बीच में बना रहता है onMessage। शुरू में एक खाली वस्तु। किसी भी उद्देश्य के लिए संशोधित करें, लेकिन यह सुनिश्चित करें कि यह एक सरणी या वस्तु है हमेशा यह सुनिश्चित करने के लिए कि वह सही ढंग से बनी रहती है।
- move(num) निर्दिष्ट स्थान पर जाएं। अमान्य होने पर कुछ नहीं करता। विवरण के लिए ऊपर देखें।
- rotate(num) निर्दिष्ट स्थिति में घुमाएँ। अमान्य होने पर कुछ नहीं करता। विवरण के लिए ऊपर देखें।
- kill() उस खिलाड़ी को मारता है जिसे आप सामना कर रहे हैं, अगर मौजूद है और आपकी टीम में नहीं है। विवरण के लिए ऊपर देखें।
- bomb() अपने आसपास के 9 चौकों में से किसी को भी मारता है, जिसमें खुद भी शामिल है।
- landMine(num) एक भूमि खदान जहां आप हैं, और उसके बाद निर्दिष्ट स्थान पर ले जाता है। अमान्य numया आपके पास कोई नहीं बचा है, तो कुछ भी नहीं करता है । विवरण के लिए ऊपर देखें।
- dig() नया! आपके आसपास केंद्रित 5x5 क्षेत्र में बारूदी सुरंगों के बारे में जानकारी की एक सरणी देता है। विवरण के लिए ऊपर देखें।
- sendMessage(recipients, team, data) recipientsया तो एक बॉट (स्ट्रिंग), बॉट की एक सरणी हो सकती है, या undefined/ null। यह वह है जिसे आप संदेश भेजना चाहते हैं। teamउस टीम का एक तार है जिसे आप संदेश भेजना चाहते हैं। "*"सभी को संदेश भेजने के लिए उपयोग करें । dataकुछ भी है कि एक जेएस समारोह के लिए पारित किया जा सकता है। यह प्राप्तकर्ताओं को भेजा जाता है। यदि यह एक ऑब्जेक्ट या सरणी है, तो इसे संदर्भ द्वारा पारित किया जाता है , इसलिए आप और प्राप्तकर्ता (ओं) को बचा सकते हैं storageऔर ऑब्जेक्ट के किसी भी संशोधन दोनों बॉट की प्रतियों को प्रभावित करते हैं। नोट प्राप्तकर्ताओं कि में हैं कि या तो बॉट की सूची, सटीक बॉट स्ट्रिंग, में निर्दिष्ट या टीम आपके द्वारा निर्दिष्ट पर एक बॉट है, यह संदेश मिल जाएगा।

environment

पहले टिक पर

x: आपके खिलाड़ी की एक्स-स्थिति
y: आपके खिलाड़ी की वाई-स्थिति
gridWidth: ग्रिड की चौड़ाई (कोशिकाओं में)
gridHeight: ग्रिड की ऊंचाई (कोशिकाओं में)

सभी टिक पर
aroundMe: खिलाड़ियों और बारूदी सुरंगों की एक सरणी। खिलाड़ी वे वस्तुएं होती हैं जो देखने में लगती हैं {name: "bot name", team: "bot team"}, और बारूदी सुरंगें हैं {team: "team of bot who placed mine"}। सरणी के अनुक्रमित:

ध्यान दें कि एक चालू के अलावा एक टिक पर रखे गए बारूदी सुरंगों को नहीं दिखाया जाएगा।

aroundMe उदाहरण:

मान लीजिए कि यह ग्रिड है (आप लाल हैं):

आपका रंग aroundMeइस तरह दिखेगा:

[
    {name: "bexamplebluebot", team: "blue"},
    undefined,//sparse array, nothing in index 1
    undefined,//there is technically a landmine here, but it wasn't placed this tick, so it is not shown
    undefined,//nothing in 3
    {name: "yexampleyellowbot", team: "yellow"},
    {team: "red"},//this is a landmine, you can tell is not a bot because it has no name. mines have the team name of the player they were placed by. This mine was placed this tick, otherwise you couldn't see it
    //nothing else after index 5, so the array's length is 5.
]

सरणी के अनुक्रमितों को यहाँ समझाया गया है:

आपका बॉट प्रभावी रूप से इसे देखता है:

onmessage(data, fromBot, fromTeam)

this (जब onmessage में)
- sendMessage(recipients, team, data) मानक संदेश भेजने का कार्य।
- storage मानक भंडारण।
dataप्रेषक से भेजा गया डेटा। fromPlayerजिस खिलाड़ी को संदेश भेजा गया था। fromTeamसंदेश जिस टीम से भेजा गया था।
onkill()

this (जब onkill में)
- sendMessage(recipients, team, data) मानक संदेश भेजने का कार्य।

सुविधाजनक (निरंतर) वैश्विक सरणियाँ:

`threeByThree`:

[
    [0, 1, 2],
    [3, undefined, 4],
    [5, 6, 7]
]

डेटा को पास फ़ंक्शन के साथ-साथ व्याख्या करने के लिए पास करने के लिए उपयोगी है aroundMe। ऊपर देखो।

`fiveByFive` :

[
    [0, 1, 2, 3, 4],
    [5, 6, 7, 8, 9],
    [10, 11, undefined, 12, 13],
    [14, 15, 16, 17, 18],
    [19, 20, 21, 22, 23]
]

हैंडलर this.dig()में फ़ंक्शन के लिए उपयोगी है ontick।

कोशिश करके देखो!

प्रदर्शन कारणों के लिए स्थानीय मशीन पर नियंत्रक को मेरी मशीन से चलाया जाएगा, लेकिन आप अपने बॉट का परीक्षण करने के लिए कोडपेन का उपयोग कर सकते हैं ।

ध्यान दें कि आपको अपना कोड कंसोल में पेस्ट करना होगा और Enterक्लिक करने से पहले दबाएं । आप जितने चाहें उतने बॉट्स में पेस्ट कर सकते हैं। "टेस्ट बॉट्स" आपके खिलाफ परीक्षण करने के लिए उदाहरण हैं। यदि आप उन सभी को हरा या बाँध सकते हैं, तो आपके पास कम से कम एक सभ्य बॉट है।

प्रस्तुतियाँ

नियम

नियम (नियंत्रक द्वारा लागू)

आपका मुख्य ontickकोड 1 सेकंड से अधिक नहीं होना चाहिए। हम हमेशा के लिए गोल नहीं लेना चाहते हैं। यदि आपका कोड> 1 सेकंड लेता है, तो इसे रोक दिया जाएगा।
यदि आप प्रति बार 1 से अधिक कार्रवाई करने का प्रयास करते हैं, या एक अमान्य कार्रवाई करते हैं (जैसे। this.move(-1)या एक दीवार में चलती है), तो इसे अनदेखा किया जाएगा।
जल्द ही और आ सकते हैं ...

नियम (मेरे द्वारा लागू, DQ में परिणाम कर सकते हैं)

वैश्विक चर मत लिखें ( पढ़ना ठीक है )।
आपका कोड Nodejs में काम करना चाहिए (यदि नियंत्रक Nodejs में पोर्ट किया गया है), तो JSON.parse(...)ठीक है, लेकिन alert()ऐसा नहीं है।
आपको createBotनियंत्रक के साथ किसी भी तरह से कॉल या हस्तक्षेप करने की अनुमति नहीं है ।
अनुमति और महत्वपूर्ण परिवर्तनों के बिना किसी और के कोड का उपयोग न करें। कोई कॉपीबॉट नहीं।
कृपया, कोई खामियों!
जल्द ही और आ सकते हैं ...

मेरे बॉट्स

यहाँ कुछ बॉट्स दिए गए हैं:

यह बॉट बेतरतीब ढंग से एक कार्रवाई चुनता है। खैर, यह एक भारित यादृच्छिक है, लेकिन अभी भी बहुत यादृच्छिक है। यदि आप इस बॉट को मार सकते हैं (यह अंततः खुद को मार देगा, जो गिनती नहीं करता है), तो आपके पास कम से कम एक सभ्य बॉट है। इसे पोस्ट करें और देखें कि क्या होता है!

कोड स्निपेट दिखाएं

createBot({
  ontick: function(environment) {
    return new Promise((resolve, reject)=>{
      if(Math.random() < 0.02){
        this.bomb();
      }else if(Math.random() < 0.1){
        this.kill();
      }else if(Math.random() < 0.3){
        this.rotate(~~(Math.random() * 4));
      }else{
        this.move(~~(Math.random() * 8));
      }
      resolve();
    });
  },
  team: "none",
  name: "xrandomness2",
  onkill: function(){
    console.log("Goodbye world... :(");
  }
});

स्निपेट का विस्तार करें

मेरे बॉट्स का नाम "x" और "कोई नहीं" की टीम से शुरू होता है। इस कोड का उपयोग करने के लिए आपका स्वागत है, लेकिन कृपया कम से कम कुछ संशोधन करें। यदि आप कम से कम एक नंबर को परेशान नहीं कर सकते हैं, तो आप जीत नहीं पाएंगे।

अपने सबमिशन को फॉर्मेट करना

कृपया इस प्रारूप का उपयोग करें:

# rmyamazingbot

    createBot({
        ontick: function(environment) {
            return new Promise((resolve, reject)=>{
                this.move(0);//example
                resolve();//please call this when you are done
            });
        },
        onmessage: function(data, fromTeam, fromBot) {
            console.log("onMessage: " + this.name + " from " + this.team + " got message ", data, " from " + from + ", on team " + fromTeam);
            this.sendMessage(["bot", "otherbot"], "team", "some data");
        },
        team: "red",//your team
        name: "rmyteamname",//team name must begin with the first letter of your team's name
        onkill: function(){
            //say goodbye
        }
    });

Long, but cool explanation...

फ़ीचर अनुरोध, बग, प्रश्न, आदि?

नीचे टिप्पणी करें! कृपया यह देखने के लिए जांचें कि क्या इसके साथ पहले से कोई टिप्पणी है। यदि पहले से कोई है, तो इसे बढ़ाएं।

अपनी टीम से बात करना चाहते हैं?

लाल और नीले रंग के लिए चैट रूम का उपयोग करें ।

भाषा

वर्तमान में, केवल JS और JS को संकलित करने वाली कुछ चीज़ों का समर्थन किया जाता है, लेकिन यदि आप Nodejs के साथ काम करने के लिए अन्य भाषाओं को प्राप्त करने के तरीके के बारे में जानते हैं, तो मुझे नियंत्रक को Nodejs में पोर्ट करने में खुशी होगी।

अंतिम नोट्स

रणनीति के विचार

अपनी टीम की मदद करें! एक बॉट बनाना जो दूसरे बॉट की मदद करने और एक साथ काम करने के लिए बनाया गया है। इस रणनीति ने रेड बनाम ब्लू - पिक्सेल टीम बैटलबोट्स के लिए अच्छा काम किया

बार-बार चाहने वाले

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

इसके अलावा, यदि आप जल्द ही जवाब देते हैं, तो आपको +100 इनाम मिल सकता है।

— programmer5000
स्रोत

1

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

— डेनिस

क्या मैं एक से अधिक बॉट बना सकता हूं? (क्षमा करें, मुझे पता है कि बातचीत को स्थानांतरित कर दिया गया है, मैं अभी-अभी चैट कर रहा हूँ हाँ)

— मैथ्यू रो

@SIGSEGV हाँ, लेकिन किसी और को इसे पोस्ट करना होगा। आप एक बॉट पोस्ट कर सकते हैं और अपनी टीम में किसी दूसरे को कोड दे सकते हैं, लेकिन आप दो बार पोस्ट नहीं कर सकते।

— प्रोग्रामर

स्थिति के बारे में, जहां [0, 0] -indexed सेल है, क्या यह शीर्ष-बाएँ सेल है? इसके अलावा, क्या मैसेजिंग आपके एक्शन (प्रति टर्न) का उपभोग करता है? धन्यवाद।

— थ्रक्स

@ थ्रैक्स हाँ, और नहीं। आप एक संदेश के जवाब में भी संदेश दे सकते हैं।

— प्रोग्रामर

7

xscared (गैर-प्रतिस्पर्धात्मक)

createBot({
    ontick: function(environment) {
        var reverse = [0, 1, 2, 3, 4, 5, 6, 7].reverse();
        return new Promise((resolve, reject)=>{
            (this.aroundMe || []).forEach((item,idx)=>{
                this.move(reverse[idx]);
                return resolve();
            });
            this.move(~~(Math.random() * 8));
            return resolve();
        });
    },
    onmessage: function() {
    },
    team: "none",
    name: "xscared",
    onkill: function(){
    }
});

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

— programmer5000
स्रोत

6

बैकअप, एक नीला बॉट

जैसा कि चैट में चेतावनी दी गई है, मैंने अपने जीवन में कभी भी जावास्क्रिप्ट में कुछ नहीं लिखा है, इसलिए यदि आपको कोई गलती मिलती है, तो कृपया मुझे बताएं! (इसके साथ पहले से ही मेरी मदद करने के लिए @ programmer5000 के लिए धन्यवाद)
इस बॉट की अवधारणा यह है कि यह एक ही टीम के अन्य बॉट्स के साथ संचार करता है और उन्हें मिली खानों के नक्शे के साथ अपनी स्थिति भेजता है। यह निकटतम ब्लू बॉट में शामिल होने की कोशिश करता है (यदि कोई अपनी स्थिति डेटा [[x, y] सरणी के रूप में दी गई है]], और उसके पास रहता है (जितना संभव हो उतना उसके पीछे वापस जाता है), लाल बॉट के निकट जाकर मारता है या देखता है खानों के लिए आगे।

createBot({
    team: 'blue',
    name: 'backup',
    ontick: function(environment) {
        return new Promise((resolve, reject) => {
            //if (typeof this.x != "undefined") this.storage['position'] = [this.x, this.y];
            if (typeof environment.x != "undefined") this.storage['position'] = [environment.x, environment.y]; //Modified according to @WasteD
            if (typeof this.storage['map'] == "undefined") { //Create empty map
                var map = [[]];
                //for(i=0;i<this.gridHeight;i++) map[i]=[];
                for(i=0;i<environment.gridHeight;i++) map[i]=[]; //Modified according to @WasteD
                this.storage['map'] = map;
            }
            var blue = []
            var red = []
            var x = this.storage['position'][0];
            var y = this.storage['position'][1];
            var dx = [-1, 0, 1, -1, 0, 1, -1, 0, 1]
            var dy = [1, 1, 1, 0, 0, 0, -1, -1, -1]
            (this.aroundMe || []).forEach((item, idx) => { // Update map and list positions of surrounding blues and reds
                if (item && item.team == 'red' && typeof item.name != "undefined") red += idx;
                if (item && item.team == 'red' && typeof item.name == "undefined") this.storage['map'][x+dx[idx]][y+dy[idx]] = 'M';
                if (item && item.team == 'blue' && typeof item.name != "undefined") blue += idx;
            });
            this.sendMessage(undefined, "blue", {"position": this.storage['position'], 'map': this.storage['map']}); //Send to buddies my position and the map
            if (red.indexOf([1, 4, 6, 3][this.direction]) > -1) this.kill() ; //If red guy is in front of
            else if (red.indexOf([1,4,6,3]) > -1) this.rotate(red.indexOf([1,4,6,3])); //If red guy is next but not in front of
            else if (blue.indexOf(3) > -1){ //If blue buddy on the left
                if (blue.indexOf(4) > -1){ //If another one is on the right
                    if (blue.indexOf(1) > -1 && this.direction != 2) this.rotate(2); //...and a third one at the top
                    else var digging = this.dig();
                    }
                else if (this.direction != 1) this.rotate(1);
                else var digging = this.dig();
            }
            else if (blue.indexOf(1) > -1){
                if (blue.indexOf(6) > -1 && this.direction != 3) this.rotate(3);
                else if (this.direction != 2) this.rotate(2);
                else var digging = this.dig();
            }
            else if (blue.indexOf(4) > -1){
                if (this.direction != 3) this.rotate(3);
                else var digging = this.dig();
            }
            else if (blue.indexOf(6) > -1 && this.direction != 0) this.rotate(0);
            else if (blue.indexOf([0,2]) > -1){ //If no blue next to me but one in diagonal, move next
                this.move(1);
                this.storage['position'][1] = y+1; //Update position
            }
            else if (blue.indexOf([5,7]) > -1){
                this.move(6);
                this.storage['position'][1] = y-1;
            }
            else if (typeof this.storage['other_blue'] != "undefined"){ //Check if buddies said where they were, try to go near the closest one
                var dmin = 99999;
                var pos = []
                (this.storage['other_blue'] || {}).forEach((item, idx) => {
                    var d = Math.sqrt(Math.pow(item['position'][0]-x,2) + Math.pow(item['position'][1]-y,2));
                    if (d < dmin){
                        dmin = d;
                        pos = item['position'];
                        }
                });
                if (pos[0]-x > 0){
                    this.move(4);
                    this.storage['position'][0] = x+1
                }
                else if (pos[0] < 0){
                    this.move(3);
                    this.storage['position'][0] = x-1
                }
                else if (pos[1] > 0){
                    this.move(1);
                    this.storage['position'][1] = y+1
                }
                else{
                    this.move(6);
                    this.storage['position'][1] = y-1
                }
            }
            else var digging = this.dig();
            if (typeof digging != "undefined"){ //Check out surroundings if dig() was played and update the map accordingly
                var dx2 = [-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2];
                var dy2 = [2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2];
                (digging || []).forEach((item, idx) => {
                    //if (item && item.team == 'red' && typeof item.name == "undefined") this.storage['map'][x+dx2[idx]][y+dy2[idx]] = 'M';
                    if (item) this.storage['map'][x+dx2[idx]][y+dy2[idx]] = 'M'; //previously misread what dig() returned
                });
            }
            resolve();
        });
    },
    onmessage: function(data, fromTeam, fromBot) {
        if (typeof data['position'] != "undefined" && fromTeam == 'blue') { //If position sent by a blue bot
            if (typeof this.storage['other_blue'] == "undefined") this.storage['other_blue'] = [];
            for (i in this.storage['other_blue']){
                var found = false;
                if ('name' in i){
                    if (i['name'] == fromBot){
                        i['position'] = data['position'];
                        found = true; //Update if position already known from previous ticks
                        }
                }
            }
            if (!found) this.storage['other_blue'] += {'position':data['position'], 'name':fromBot}; //Add position if previously unknown
            this.sendMessage(fromBot, undefined, "roger.");
        }
    },
    onkill: function() {this.sendMessage(undefined, "blue", {"position": this.storage['position'], 'map': this.storage['map']});}
});

— plannapus
स्रोत

अरे आप परवाह करते हैं अगर मैं भी इसमें प्रवेश करता हूं लेकिन (अलग नाम के साथ) मैं नीले रंग में भी हूं

— क्रिस्टोफर

@Christopher नहीं, मुझे कोई आपत्ति नहीं है, लेकिन यह आपके लिए और टीम के लिए थोड़ा अधिक दिलचस्प होगा यदि आप कम से कम थोड़ा अलग करते हैं (कम से कम 2 बॉट्स जो पहले से मौजूद हैं उन्हें पूरक करने के लिए)।

— प्लेनैपस

वह करेगा। मैं इसे बदल दूंगा

— क्रिस्टोफर

अगर मैं कोडपैन में आपके बॉट को चलाने की कोशिश करता हूं तो यह काम नहीं करता है क्योंकि आप उपयोग कर रहे हैं this.xऔर इसी तरह से यह environment.xगलत है या मैं गलत हूं?

— वशिष्ट

@WasteD जैसा कि मैंने कहा कि मैं जावास्क्रिप्ट को बिल्कुल नहीं जानता, इसलिए यह संभव है। लेकिन अगर ऐसा है तो मुझे लगता है कि यह भी होना चाहिए environment.gridHeightऔर environment.aroundMe? इस मामले में तब अन्य बॉट काम नहीं करना चाहिए क्योंकि वे उपयोग करते हैं this.aroundMe।

— प्लेनैपस

5

नीला, नीला, मेरी दुनिया नीली है

createBot({
    team: 'blue',
    name: 'blue-blue-my-world-is-blue',
    ontick: function(environment) {
        return new Promise((resolve, reject) => {
            var red = 0;
            // See who's around me
            (this.aroundMe || []).forEach((item, idx) => {
                if (item && item.team == 'red') red++;
            });
            // If surrounded, take one for the team
            if (red >= 6) this.bomb();
            else {
                // Translate direction into position
                var kill = [1, 4, 6, 3][this.direction];
                // Random values
                var move = Math.floor(Math.random() * 8);
                var nsew = Math.floor(Math.random() * 4);
                // Lay a landmine if possible
                if (this.landMines) this.landMine(move);
                // Kill if someone is in the way
                else if (this.aroundMe && this.aroundMe[kill] && this.aroundMe[kill].team == 'red' && this.aroundMe[kill].name) this.kill();
                else {
                    // Move somewhere if already in the requested direction
                    if (nsew == this.direction) this.move(move);
                    // Otherwise just rotate to the requested direction
                    else this.rotate(nsew);
                }
            }
            resolve();
        });
    },
    onmessage: function(data, from, fromBot) {},
    onkill: function() {}
});

ज्यादातर बेतरतीब, लेकिन अगर चारों ओर बम होगा, और चारों ओर जाँच करने और आगे बढ़ने पर मारने का एहसान होगा।

होशियार! अच्छा है।

— प्रोग्रामर

3

यो सुनो, यहाँ एक कहानी है, एक छोटे से लड़के के बारे में जो एक नीली दुनिया में रहता है।

— मैथ्यू रो

3

आराम-बॉम्बर

यह बॉट प्रत्येक पक्ष पर कम से कम 1 नि: शुल्क सेल के साथ एक स्पॉट की खोज करता है और फिर एक खदान को जोड़ता है। यह उस पर तब तक कैंप करता है जब तक कोई दुश्मन नहीं पहुंचता। जब कोई पास आता है, तो वह दूसरे खदान पर चारा डालने के लिए अपनी खदान पर आगे-पीछे करता है। जरूरत पड़ने पर वह घुमाएगा और मार भी देगा। जब उसके पास कोई खदान नहीं बचती है, तो वह दीवार पर अपनी पीठ के साथ ऊपरी-बाएँ कोने पर शरण लेगा और अगर खतरा हो तो जवाबी कार्रवाई करेगा।

यहां कोई विशेष टीमप्ले नहीं है, इसके अलावा अपनी स्थिति को selfकीवर्ड के साथ अपनी टीम में प्रसारित करने के अलावा ।

createBot({
    team: 'red',
    name: 'relaxed-bomber',
    ontick: function(environment) {
        return new Promise((resolve, reject) => {
            if (typeof this.storage['dropped'] == "undefined") {
                this.storage['dropped'] = false;
                this.storage['covered'] = false;
                this.storage['baited'] = false;
            }
            if (typeof environment.x != "undefined" && typeof environment.y != "undefined") {
                this.storage['pos'] = [environment.x, environment.y];
            }
            if (typeof environment.gridWidth != "undefined" && typeof environment.gridHeight != "undefined") {
                this.storage['grid'] = [environment.gridWidth, environment.gridHeight];
            }
            var x = this.storage['pos'][0];
            var y = this.storage['pos'][1];
            var x0 = this.storage['grid'][0];
            var y0 = this.storage['grid'][1];
            var source = [1, 4, 6, 3];
            var dest = [6, 3, 1, 4];
            var rot = [0, 1, 2, 3];
            var movex = [-1, 0, 1, -1, 1, -1, 0, 1];
            var movey = [-1, -1, -1, 0, 0, 1, 1, 1];
            var action = false;
            if (this.landMines > 0) { 
                var move = [false, false, false, false];
                var moveIndex = -1;
                if (x <= 0) { move[1] = true; }
                if (x >= x0 - 1) { move[3] = true; }
                if (y <= 0) { move[2] = true; }
                if (y >= y0 - 1) { move[0] = true; }    
                if (move[0] && !move[1] && !move[2] && move[3]) { moveIndex = 0; }
                if (move[0] && !move[1] && !move[2] && !move[3]) { moveIndex = 1; }
                if (move[0] && move[1] && !move[2] && !move[3]) { moveIndex = 2; }
                if (!move[0] && !move[1] && !move[2] && move[3]) { moveIndex = 3; }
                if (!move[0] && move[1] && !move[2] && !move[3]) { moveIndex = 4; }
                if (!move[0] && !move[1] && move[2] && move[3]) { moveIndex = 5; }
                if (!move[0] && !move[1] && move[2] && !move[3]) { moveIndex = 6; }
                if (!move[0] && move[1] && move[2] && !move[3]) { moveIndex = 7; }  
                if (moveIndex >= 0) {
                    this.storage['pos'] = [ x + movex[moveIndex], y + movey[moveIndex]];
                    this.move(moveIndex);
                } else {
                    this.storage['dropped'] = true;
                    this.storage['covered'] = false;
                    this.landMine(1);
                }
            } else {
                if (this.storage['dropped']) {
                    this.storage['dropped'] = false;
                    this.storage['covered'] = true;
                    this.storage['pos'] = [ x + movex[6], y + movey[6]];
                    this.move(6);
                } else if (this.storage['covered']) {
                    for (var i = 0; i < source.length; i++) {
                        if (typeof environment.aroundMe[source[i]] != "undefined" && typeof environment.aroundMe[source[i]].team != "undefined" && environment.aroundMe[source[i]].team == "blue" && typeof environment.aroundMe[source[i]].name != "undefined") {
                            this.storage['covered'] = false;
                            this.storage['baited'] = true;
                            this.storage['mine'] = this.storage['pos'].slice();
                            this.storage['reverse'] = source[dest[i]];
                            this.storage['pos'] = [ x + movex[dest[i]], y + movey[dest[i]]];
                            this.move(dest[i]);
                            action = true;
                        }
                    }
                    if (!action) {
                        this.dig();
                    }
                } else if (this.storage['baited']) {
                    for (var i = 0; i < source.length; i++) {
                        if (typeof environment.aroundMe[source[i]] != "undefined" && typeof environment.aroundMe[source[i]].team != "undefined" && environment.aroundMe[source[i]].team == "blue" && typeof environment.aroundMe[source[i]].name != "undefined") {
                            if (this.direction == rot[source[i]]) {
                                this.kill();
                                this.storage['baited'] = false;
                                action = true;
                            } else {
                                this.rotate(rot[source[i]]);
                                action = true;
                            }
                        }
                    }
                    if (!action) {
                        if (this.storage['mine'][0] == this.storage['pos'][0] && this.storage['mine'][1] == this.storage['pos'][1]) {
                            this.storage['pos'] = [ x + movex[this.storage['reverse']], y + movey[this.storage['reverse']]];
                            this.move(this.storage['reverse']);
                            this.storage['reverse'] = source[this.storage['reverse']];
                        } else {
                            this.storage['pos'] = [ x + movex[this.storage['reverse']], y + movey[this.storage['reverse']]];
                            this.move(this.storage['reverse']);
                            this.storage['reverse'] = dest[this.storage['reverse']];
                        }
                    }
                } else {
                    for (var i = 0; i < source.length; i++) {
                        if (typeof environment.aroundMe[source[i]] != "undefined" && typeof environment.aroundMe[source[i]].team != "undefined" && environment.aroundMe[source[i]].team == "blue" && typeof environment.aroundMe[source[i]].name != "undefined") {
                            if (this.direction == rot[source[i]]) {
                                this.kill();
                                this.storage['baited'] = false;
                                action = true;
                            } else {
                                this.rotate(rot[source[i]]);
                                action = true;
                            }
                        }
                    }
                    if (!action) {
                        if (x > 0 && y > 0) {
                            this.storage['pos'] = [ x + movex[0], y + movey[0]];
                            this.move(0);
                        } else if (x > 0 && y == 0) {
                            this.storage['pos'] = [ x + movex[3], y + movey[3]];
                            this.move(3);
                        } else if (x == 0 && y > 0) {
                            this.storage['pos'] = [ x + movex[1], y + movey[1]];
                            this.move(1);
                        } else {
                            this.rotate(1);
                        }
                    }
                }
            }
            this.sendMessage(undefined, "red", {'self': this.storage['pos'] });
            resolve();
        });
    },
    onmessage: function(data, fromTeam, fromBot) {},
    onkill: function() {}
});

— Thrax
स्रोत

आप किस टीम में हैं?

— प्रोग्रामर

@ प्रोग्रामर 5000 चूंकि बॉट्स के नाम टीम के अक्षर से शुरू होते हैं, मुझे लगता है कि मैं टीम रेड हूं :)

— थ्रक्स

अच्छा बॉट! मैं आपको सुझाव देता हूं कि आप अपनी टीम के लिए क्या करें

— प्रोग्रामर

1

बैकअप 1 दूसरा नीला बॉट (पहले ऐसा करना भूल गया)

createBot({
    team: 'blue',
    name: 'backup1',
    ontick: function(environment) {
        return new Promise((resolve, reject) => {
            //if (typeof this.x != "undefined") this.storage['position'] = [this.x, this.y];
            if (typeof environment.x != "undefined") this.storage['position'] = [environment.x, environment.y]; //Modified according to @WasteD
            if (typeof this.storage['map'] == "undefined") { //Create empty map
                var map = [[]];
                //for(i=0;i<this.gridHeight;i++) map[i]=[];
                for(i=0;i<environment.gridHeight;i++) map[i]=[]; //Modified according to @WasteD
                this.storage['map'] = map;
            }
            var blue = []
            var red = []
            var x = this.storage['position'][0];
            var y = this.storage['position'][1];
            var dx = [-1, 0, 1, -1, 0, 1, -1, 0, 1]
            var dy = [1, 1, 1, 0, 0, 0, -1, -1, -1]
            (this.aroundMe || []).forEach((item, idx) => { // Update map and list positions of surrounding blues and reds
                if (item && item.team == 'red' && typeof item.name != "undefined") red += idx;
                if (item && item.team == 'red' && typeof item.name == "undefined") this.storage['map'][x+dx[idx]][y+dy[idx]] = 'M';
                if (item && item.team == 'blue' && typeof item.name != "undefined") blue += idx;
            });
            this.sendMessage(undefined, "blue", {"position": this.storage['position'], 'map': this.storage['map']}); //Send to buddies my position and the map
            if (red.indexOf([1, 4, 6, 3][this.direction]) > -1) this.kill() ; //If red guy is in front of
            else if (red.indexOf([1,4,6,3]) > -1) this.rotate(red.indexOf([1,4,6,3])); //If red guy is next but not in front of
            else if (blue.indexOf(3) > -1){ //If blue buddy on the left
                if (blue.indexOf(4) > -1){ //If another one is on the right
                    if (blue.indexOf(1) > -1 && this.direction != 2) this.rotate(2); //...and a third one at the top
                    else var digging = this.dig();
                    }
                else if (this.direction != 1) this.rotate(1);
                else var digging = this.dig();
            }
            else if (blue.indexOf(1) > -1){
                if (blue.indexOf(6) > -1 && this.direction != 3) this.rotate(3);
                else if (this.direction != 2) this.rotate(2);
                else var digging = this.dig();
            }
            else if (blue.indexOf(4) > -1){
                if (this.direction != 3) this.rotate(3);
                else var digging = this.dig();
            }
            else if (blue.indexOf(6) > -1 && this.direction != 0) this.rotate(0);
            else if (blue.indexOf([0,2]) > -1){ //If no blue next to me but one in diagonal, move next
                this.move(1);
                this.storage['position'][1] = y+1; //Update position
            }
            else if (blue.indexOf([5,7]) > -1){
                this.move(6);
                this.storage['position'][1] = y-1;
            }
            else if (typeof this.storage['other_blue'] != "undefined"){ //Check if buddies said where they were, try to go near the closest one
                var dmin = 99999;
                var pos = []
                (this.storage['other_blue'] || {}).forEach((item, idx) => {
                    var d = Math.sqrt(Math.pow(item['position'][0]-x,2) + Math.pow(item['position'][1]-y,2));
                    if (d < dmin){
                        dmin = d;
                        pos = item['position'];
                        }
                });
                if (pos[0]-x > 0){
                    this.move(4);
                    this.storage['position'][0] = x+1
                }
                else if (pos[0] < 0){
                    this.move(3);
                    this.storage['position'][0] = x-1
                }
                else if (pos[1] > 0){
                    this.move(1);
                    this.storage['position'][1] = y+1
                }
                else{
                    this.move(6);
                    this.storage['position'][1] = y-1
                }
            }
            else var digging = this.dig();
            if (typeof digging != "undefined"){ //Check out surroundings if dig() was played and update the map accordingly
                var dx2 = [-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2,-2,-1,0,1,2];
                var dy2 = [2,2,2,2,2,1,1,1,1,1,0,0,0,0,0,-1,-1,-1,-1,-1,-2,-2,-2,-2,-2];
                (digging || []).forEach((item, idx) => {
                    //if (item && item.team == 'red' && typeof item.name == "undefined") this.storage['map'][x+dx2[idx]][y+dy2[idx]] = 'M';
                    if (item) this.storage['map'][x+dx2[idx]][y+dy2[idx]] = 'M'; //previously misread what dig() returned
                });
            }
            resolve();
        });
    },
    onmessage: function(data, fromTeam, fromBot) {
        if (typeof data['position'] != "undefined" && fromTeam == 'blue') { //If position sent by a blue bot
            if (typeof this.storage['other_blue'] == "undefined") this.storage['other_blue'] = [];
            for (i in this.storage['other_blue']){
                var found = false;
                if ('name' in i){
                    if (i['name'] == fromBot){
                        i['position'] = data['position'];
                        found = true; //Update if position already known from previous ticks
                        }
                }
            }
            if (!found) this.storage['other_blue'] += {'position':data['position'], 'name':fromBot}; //Add position if previously unknown
            this.sendMessage(fromBot, undefined, "roger.");
        }
    },
    onkill: function() {this.sendMessage(undefined, "blue", {"position": this.storage['position'], 'map': this.storage['map']});}
});

— क्रिस्टोफर
स्रोत

1

ब्लू फाइटर

createBot({
  team: "blue",
  name: "blue-fighter",
  ontick: function(environment) {
    return new Promise((resolve, reject)=>{
      let map = environment.aroundMe;
      let sides = [1, 4, 6, 3];
      let facing = sides[this.direction];
      let isTeam = (team,a) => a && a.team === team;
      let isRed = (a)=>isTeam("red",a);
      let isBlue = (a)=>isTeam("blue",a);
      let randomSquare = ()=>Math.floor(Math.random()*8);
      let redNum = map.filter(isRed).length;
      let blueNum =  map.filter(isBlue).length;
      if(redNum > blueNum && redNum > 2){
        this.bomb();
      }else if(isRed(map[facing])){
        this.kill();
      }else if(sides.includes(map.findIndex(isRed))){
        this.rotate(sides.indexOf(map.findIndex(isRed)));
      }else if(Math.random() < 0.5 && this.landMines > 0){
        this.landMine(randomSquare());
      }else{            
        this.move(randomSquare());
      }
      resolve();
    });
  },
  onmessage: function(data, from, fromBot) {},
  onkill: function(){}
});

ब्लू फाइटर चलता है और बारूदी सुरंगों को बेतरतीब ढंग से घुमाता है और लाल खिलाड़ियों की ओर घूमता है। यदि आसपास के ब्लॉकों में नीले रंग की तुलना में अधिक लाल है, तो यह बम होता है। यदि यह एक लाल खिलाड़ी का सामना कर रहा है, तो यह इसे मारता है।

— SuperStormer
स्रोत

हिल की टीम!

अवलोकन

तुम्हारी टीम

आपका (बॉट का) नाम

शुरुआत में

अपनी बारी पर

क्रियाओं को चालू करें

चाल

घुमाएँ

को मार डालो

बम

एक बारूदी सुरंग लगाएं

गड्ढा करना

संचार

"रेडिसबेस्ट" नामक एक बॉट में कुछ भेजें:

"रेडिसबेस्ट" और "ब्लूस्कूल" नामक बॉट में कुछ भेजें:

पूरी रेड टीम को कुछ भेजें

सभी को कुछ न कुछ भेजें

पूरी रेड टीम और "ब्लूस्कूल" नामक बॉट को कुछ भेजें:

एपीआई

आपके कोड में फ़ंक्शन के लिए एक कॉल शामिल होना चाहिए createBot। और कुछ नहीं। नमूना कोड:

तरीके

सुविधाजनक (निरंतर) वैश्विक सरणियाँ:

threeByThree:

fiveByFive :

कोशिश करके देखो!

प्रस्तुतियाँ

नियम

नियम (नियंत्रक द्वारा लागू)

नियम (मेरे द्वारा लागू, DQ में परिणाम कर सकते हैं)

मेरे बॉट्स

अपने सबमिशन को फॉर्मेट करना

फ़ीचर अनुरोध, बग, प्रश्न, आदि?

अपनी टीम से बात करना चाहते हैं?

भाषा

अंतिम नोट्स

रणनीति के विचार

बार-बार चाहने वाले

xscared (गैर-प्रतिस्पर्धात्मक)

बैकअप, एक नीला बॉट

नीला, नीला, मेरी दुनिया नीली है

आराम-बॉम्बर

बैकअप 1 दूसरा नीला बॉट (पहले ऐसा करना भूल गया)

ब्लू फाइटर

आपके कोड में फ़ंक्शन के लिए एक कॉल शामिल होना चाहिए `createBot`। और कुछ नहीं। नमूना कोड:

`threeByThree`:

`fiveByFive` :