रेड बनाम ब्लू - पिक्सेल टीम बैटलबोट्स


133

यह प्रतियोगिता आधिकारिक रूप से समाप्त हो गई है। ब्लू टीम जीती!

मैंने 50 लड़ाइयों के दो सेट और आश्चर्यजनक रूप से, ब्लू ने उनमें से सभी 100 जीते। आंकड़ों को देखते हुए, यह स्पष्ट है कि PhiNotPi और Sp3000 की सहकारी प्रविष्टियाँ असली हीरो थीं। महान काम आप दो! वास्तव में, यदि आप ब्लू टीम के हर दूसरे सदस्य को अयोग्य ठहराते हैं, तो स्फीबॉट्स अभी भी एक बहुत अच्छी लड़ाई डालते हैं । रेड टीम के कुछ लोग स्फीबोट्स को उतारने की योजना बना रहे थे , लेकिन यह प्रयास कमतर लग रहा था। सॉरी रेड टीम।

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


यह एक राजा-की-पहाड़ी प्रतियोगिता है, लेकिन सभी के लिए एक-दूसरे के खिलाफ लड़ने के बजाय, दो टीमें होंगी जो प्रतिस्पर्धा करेंगी: रेड और ब्लू। केवल एक ही विजेता होगा।

आप जिस टीम में हैं, वह आपके पीपीसीजी उपयोगकर्ता आईडी नंबर पर निर्भर करता है । इसे खोजने के लिए, स्क्रीन के शीर्ष पर अपना अवतार क्लिक करें (आपको लॉग इन होना चाहिए) और खुलने वाले पृष्ठ के यूआरएल को देखें। users/आपके आईडी नंबर के बाद का नंबर है:

https://codegolf.stackexchange.com/users/[id number]/[display name]

उदाहरण के लिए, मेरा PPCG उपयोगकर्ता आईडी नंबर 26997 है:

https://codegolf.stackexchange.com/users/26997/calvins-hobbies

ध्यान दें कि यह संख्या विभिन्न स्टैक एक्सचेंज साइटों के लिए अलग है।

यदि आपकी आईडी एक सम संख्या है , तो आप रेड टीम पर हैं
यदि आपकी आईडी एक विषम संख्या है , तो आप ब्लू टीम पर हैं
टीमों को बदलने का कोई तरीका नहीं है।

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

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

function toggleDebug(){debug=$("#debug").is(":checked")}function rnd(e){return Math.floor(Math.random()*e)}function shuffle(e){for(var t,a,r=e.length;r;t=rnd(r),a=e[--r],e[r]=e[t],e[t]=a);return e}function maskedEval(e,t){var a={};for(i in this)a[i]=void 0;for(i in t)t.hasOwnProperty(i)&&(a[i]=t[i]);return new Function("with(this) { "+e+";}").call(a)}function createBattle(e,t,a,r){function n(){var e=rnd(i.length),t=i[e];return i.splice(e,1),t}var l={};l.width=l.height=128,l.totalMoves=2048,l.radius=16,l.msgMaxLength=64,l.timeLimit=15,l.move=0,l.redToMove=a,l.animated=r,l.running=!1,l.over=!1;for(var o=0,i=new Array(l.width*l.height),d=0;d<l.height;d++)for(var s=0;s<l.width;s++)i[o++]={x:s,y:d};l.redTeam=shuffle(e.slice()),l.redMsgs={},l.redKills={};for(var o=0;o<l.redTeam.length;o++){var u=n();l.redTeam[o].x=u.x,l.redTeam[o].y=u.y,l.redMsgs[l.redTeam[o].id]="",l.redKills[l.redTeam[o].id]=0}l.blueTeam=shuffle(t.slice()),l.blueMsgs={},l.blueKills={};for(var o=0;o<l.blueTeam.length;o++){var u=n();l.blueTeam[o].x=u.x,l.blueTeam[o].y=u.y,l.blueMsgs[l.blueTeam[o].id]="",l.blueKills[l.blueTeam[o].id]=0}return l}function drawBattle(e){function t(e){var t=3*e.x,a=3*e.y;ctx.fillRect(t,a,3,3),showNames.is(":checked")&&ctx.fillText(e.title,t+5,a+12)}function a(t){ctx.beginPath(),ctx.arc(3*t.x,3*t.y,3*e.radius,0,2*Math.PI),ctx.closePath(),ctx.fill()}e.animated&&(ctx.clearRect(0,0,canvas.width,canvas.height),showCircles.is(":checked")&&(ctx.fillStyle="rgba(255, 0, 0, 0.1)",e.redTeam.forEach(a),ctx.fillStyle="rgba(0, 0, 255, 0.1)",e.blueTeam.forEach(a)),ctx.fillStyle="red",e.redTeam.forEach(t),ctx.fillStyle="blue",e.blueTeam.forEach(t),moveCounter.text((e.move+1).toString()))}function movePlayer(e,t,a,r,n,l,o,i){function d(a){t.id!==a.id&&Math.sqrt(Math.pow(t.x-a.x,2)+Math.pow(t.y-a.y,2))<e.radius&&(u.push({x:a.x,y:a.y,id:a.id}),debug&&console.log(a.title+" is near"))}debug&&(console.log("--- Moving "+t.title+" ---"),console.log("position before move = ("+t.x.toString()+", "+t.y.toString()+")"));var s={};s.move=a,s.x=t.x,s.y=t.y,s.tCount=r.length,s.eCount=n.length,s.setMsg=function(a){"string"==typeof a&&(l[t.id]=a.length>e.msgMaxLength?a.substring(0,e.msgMaxLength):a,debug&&console.log('set message to "'+l[t.id]+'"'))},s.getMsg=function(e){var t=l.hasOwnProperty(e)?l[e]:void 0;return debug&&console.log('got message "'+t+'" from player with id '+e.toString()),t};var u=[];r.forEach(d),s.tNear=u,u=[],n.forEach(d),s.eNear=u,-1===t.id&&(s.console=console);var c=0,g=performance.now();try{c=maskedEval(t.code,s)}catch(v){c=0,debug&&(console.log("encountered error:"),console.log(v))}g=performance.now()-g,debug&&console.log("time taken = "+g.toString()+"ms"),g>e.timeLimit&&(c=0,debug&&console.log("went over the time limit of "+e.timeLimit+"ms"));var m=t.x,h=t.y;switch(c){case 1:e.redToMove?++m:++h;break;case 2:e.redToMove?--m:--h;break;case 3:++m,--h;break;case 4:--m,--h;break;case 5:--m,++h;break;case 6:++m,++h}m>=0&&m<e.width&&h>=0&&h<e.height&&(t.x=m,t.y=h),debug&&console.log("move direction = "+c);for(var f=0;f<n.length;f++)t.x===n[f].x&&t.y===n[f].y&&(debug&&console.log("took out "+n[f].title),++i[t.id],o[n[f].id]="X",n.splice(f--,1))}function advanceBattle(e){debug&&console.log("====== "+(e.redToMove?"Red ":"Blue ")+e.move.toString()+" ======");var t,a,r,n,l;e.redToMove?(t=e.redTeam,a=e.blueTeam,r=e.redMsgs,n=e.blueMsgs,l=e.redKills):(t=e.blueTeam,a=e.redTeam,r=e.blueMsgs,n=e.redMsgs,l=e.blueKills),t.forEach(function(o){movePlayer(e,o,Math.floor(e.move/2)+1,t,a,r,n,l)}),drawBattle(e);var o;return 0===a.length?(o=e.redToMove?1:-1,e.over=!0):++e.move>=e.totalMoves&&(o=e.redTeam.length>e.blueTeam.length?1:e.redTeam.length<e.blueTeam.length?-1:0,e.over=!0),e.redToMove=!e.redToMove,debug&&"undefined"!=typeof o&&console.log("win status = "+o.toString()),o}function newBattle(){if(0===redTeam.length||0===blueTeam.length)return void alert("Each team must have at least one player.");"undefined"!=typeof interval&&clearInterval(interval);var e=parseInt($("#delay").val());return isNaN(e)||0>e?void alert("Delay must be a non-negative integer."):(debug&&console.log("Created new battle with delay "+e.toString()),battle=createBattle(redTeam,blueTeam,$("#redMovesFirst").is(":checked"),!0),drawBattle(battle),void moveCounter.text("0").css("color","black"))}function reportKills(e,t){for(var a="Red Kills:\n",r=0;r<redTeam.length;r++)a+=e[redTeam[r].id].toString()+" by "+redTeam[r].title+"\n";a+="\nBlue Kills:\n";for(var r=0;r<blueTeam.length;r++)a+=t[blueTeam[r].id].toString()+" by "+blueTeam[r].title+"\n";return a}function intervalCallback(){var e=advanceBattle(battle);"undefined"!=typeof e&&(clearInterval(interval),battle.running=!1,alert([0===e?"Tie!":e>0?"Red Wins!":"Blue Wins!","Red remaining: "+battle.redTeam.length,"Blue remaining: "+battle.blueTeam.length,"\n"].join("\n")+reportKills(battle.redKills,battle.blueKills)))}function run(){if("undefined"!=typeof battle&&!battle.running&&!battle.over){battle.running=!0;var e=parseInt($("#delay").val());if(isNaN(e)||0>e)return void alert("Delay must be a non-negative integer.");interval=setInterval(intervalCallback,e)}}function pause(){"undefined"!=typeof battle&&(battle.running=!1),"undefined"!=typeof interval&&clearInterval(interval)}function step(){"undefined"==typeof battle||battle.running||battle.over||intervalCallback()}function autorunBattles(){function e(e){for(var t,i=createBattle(redTeam,blueTeam,e,!1);!i.over;)if(t=advanceBattle(i),"undefined"!=typeof t){i.over=!0,1===t?++a:-1===t?++n:++r;for(var d in i.redKills)i.redKills.hasOwnProperty(d)&&(l[d]+=i.redKills[d]);for(var d in i.blueKills)i.blueKills.hasOwnProperty(d)&&(o[d]+=i.blueKills[d])}}if(pause(),battle=void 0,0===redTeam.length||0===blueTeam.length)return void alert("Each team must have at least one player.");var t=parseInt($("#N").val());if(isNaN(t)||0>t)return void alert("N must be a non-negative integer.");console.log("Autorunning "+t.toString()+" battles");for(var a=0,r=0,n=0,l={},o={},i=0;i<redTeam.length;i++)l[redTeam[i].id]=0;for(var i=0;i<blueTeam.length;i++)o[blueTeam[i].id]=0;for(var i=0;t>i;i++)console.log("Battle "+i.toString()),e(i%2===0);alert([a===n?"Tie overall!":a>n?"Red wins overall!":"Blue wins overall!","Red wins: "+a.toString(),"Blue wins: "+n.toString(),"Ties: "+r.toString(),"\n"].join("\n")+reportKills(l,o))}function changeSelect(e){var t=e?redTeam:blueTeam,a=$(e?"#redSelect":"#blueSelect").val(),r=$(e?"#redCode":"#blueCode"),n=$(e?"#redLink":"#blueLink");null!==a&&a>-1?(r.text(t[a].code),n.attr("href",t[a].link)):(r.text(""),n.attr("href","javascript:;"))}function loadEntries(){function e(e,t){url="https://api.stackexchange.com/2.2/questions/"+qid.toString()+"/answers?page="+e.toString()+"&pagesize=100&order=asc&sort=creation&site=codegolf&filter=!JDuPcYJfXobC6I9Y-*EgYWAe3jP_HxmEee",$.get(url,t)}function t(d){d.items.forEach(function(e){function t(e,t){t.append(" ").append($("<a>").text(e.owner.display_name).attr("href",e.link))}function n(e){return $("<textarea>").html(e).text()}var d=e.owner.user_id%2===0,s=d?redTeam:blueTeam;if(e.owner.display_name=n(e.owner.display_name),e.hasOwnProperty("last_edit_date")&&e.last_edit_date-e.creation_date>r||dq.indexOf(e.owner.user_id)>-1||l.indexOf(e.owner.user_id)>-1)return void t(e,o);l.push(e.owner.user_id);var u=a.exec(e.body);if(null===u||u.length<=1)return void t(e,i);var c={};c.id=e.owner.user_id,c.title=e.owner.display_name+" ["+e.owner.user_id.toString()+"]",c.code=n(u[1]),c.link=e.link;var g=$(d?"#redSelect":"#blueSelect");g.append($("<option>").text(c.title).val(s.length)),s.push(c)}),d.has_more?e(++n,t):($("#loadStatus").hide(),$("#redCount").text(redTeam.length.toString()),$("#blueCount").text(blueTeam.length.toString()),0===o.html().length&&o.html(" none"),0===i.html().length&&i.html(" none"))}var a=/<pre><code>((?:\n|.)*?)\n<\/code><\/pre>/,r=28800,n=1,l=[],o=$("#disqualified"),i=$("#invalid");pause(),battle=void 0,redTeam=[],blueTeam=[],$("#loadStatus").show(),$("#redSelect").empty(),$("#redCode").empty(),$("#redLink").attr("href","javascript:;"),$("#blueSelect").empty(),$("#blueCode").empty(),$("#blueLink").attr("href","javascript:;");var d=$("#testbot").val();if(d.length>0){debug&&console.log("Using test entry");var s={id:-1,title:"TEST ENTRY [-1]",link:"javascript:;",code:d};$("#testbotIsRed").is(":checked")?(redTeam.push(s),$("#redSelect").append($("<option>").text(s.title).val(0))):(blueTeam.push(s),$("#blueSelect").append($("<option>").text(s.title).val(0)))}e(1,t)}var qid=48353,dq=[],ctx,moveCounter,showNames,showCircles,debug=!1,battle,redTeam,blueTeam,interval;$(document).ready(function(){ctx=$("#canvas")[0].getContext("2d"),moveCounter=$("#moveCounter"),showNames=$("#showNames"),showCircles=$("#showCircles"),loadEntries()});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><style>html *{font-family: Consolas, Arial, sans-serif;}select{width: 100%; margin: 12px 0 0 0;}button, select, input{font-size: 100%;}input{text-align: right;}textarea{font-family: "Courier New", monospace;}textarea[readonly]{background-color: #eee; width: 100%;}canvas{margin: 12px 0 0 0; border: 2px solid gray;}.redWrapper, .blueWrapper{width: 30%;}.redWrapper{float: left;}.blueWrapper{float: right;}.arenaWrapper{width: 40%; display: inline-block;}.redTeam, .blueTeam, .arena{padding: 12px;}.arena{text-align: center;}.redTeam, .blueTeam{border-style: solid; border-width: medium;}.redTeam{border-color: red; background-color: #fee;}.blueTeam{border-color: blue; background-color: #eef;}.redTitle, .blueTitle, .arenaTitle{text-align: center; font-size: 200%;}.redTitle, .blueTitle{font-weight: bold;}.redTitle{color: red;}.blueTitle{color: blue;}.control{margin: 12px 0 0 0;}.count{font-size: 75%; margin: 0 0 12px 0;}.footnotes{font-size: 75%; clear: both; padding: 12px;}</style><div id='loadStatus'> Loading entries...</div><div> <div class='redWrapper'> <div class='redTeam'> <div class='redTitle'> Red Team </div><select id='redSelect' size='20' onchange='changeSelect(true)'> </select> <div class='count'> <span id='redCount'></span> players </div>Code: <br><textarea id='redCode' rows='12' readonly></textarea> <br><a id='redLink' href='javascript:;'> Answer Link </a> </div></div><div class='arenaWrapper'> <div class='arena'> <div class='arenaTitle'> Battlefield </div><canvas id='canvas' width='384' height='384'> Your browser does not support the canvas tag. </canvas> <div>Move <span id='moveCounter'>0</span></div><br><div> <div class='control'> <input id='showNames' type='checkbox'>show names <input id='showCircles' type='checkbox'>show circles </div><div class='control'> <input id='redMovesFirst' type='checkbox'>red moves first </div><div class='control'> <input id='delay' type='text' size='4' value='20'> millisecond delay </div><div class='control'> <button type='button' onclick='newBattle()'> New Battle </button> <button type='button' onclick='run()'> Run </button> <button type='button' onclick='pause()'> Pause </button> <button type='button' onclick='step()'> Step </button> </div><hr class='control'> <div class='control'> <button type='button' onclick='autorunBattles()'> Autorun N Battles </button> N&nbsp;=&nbsp;<input id='N' type='text' size='4' value='16'> </div><div class='footnotes'> Autoruns may hang browser tab until complete. </div></div></div></div><div class='blueWrapper'> <div class='blueTeam'> <div class='blueTitle'> Blue Team </div><select id='blueSelect' size='20' onchange='changeSelect(false)'> </select> <div class='count'> <span id='blueCount'></span> players </div>Code: <br><textarea id='blueCode' rows='12' readonly></textarea> <br><a id='blueLink' href='javascript:;'> Answer Link </a> </div></div></div><div class='footnotes'> Test Entry: (id&nbsp;=&nbsp;-1) <input id='testbotIsRed' type='checkbox'>On Red Team <br><textarea id='testbot' rows='1' cols='32'></textarea> <br><button type='button' onclick='loadEntries()'> Reload with test entry </button> <br><br>This was designed and tested in Google Chrome. It might not work in other browsers. <br>Disqualified entries:<span id='disqualified'></span> <br>Could not find code block:<span id='invalid'></span> <br><input id='debug' type='checkbox' onclick='toggleDebug()'>Debug messages <br></div>

दृश्यता के लिए, स्निपेट का युद्धक्षेत्र 3 के एक कारक द्वारा बढ़ाया जाता है, इसलिए यह 384 × 384 वास्तविक पिक्सेल है और "पिक्सेल" 3 × 3 हैं।

पिक्सेल टीम बैटलबोट्स - ओवरव्यू

खिलाड़ियों

इस प्रश्न का प्रत्येक मान्य उत्तर एक खिलाड़ी का प्रतिनिधित्व करता है । (वैधता के विवरण के लिए, "नियम और अयोग्यता" देखें ।) प्रत्येक खिलाड़ी का 128 × 128 सेल युद्ध के मैदान पर एक एकल 1 × 1 सेल (उर्फ पिक्सेल) पर नियंत्रण होता है । रेड टीम के खिलाड़ियों के पास लाल पिक्सेल होते हैं और ब्लू टीम के खिलाड़ियों के पास नीले पिक्सेल होते हैं।

लड़ाई

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

चालें

प्रत्येक लड़ाई 2048 चालों में टूट जाती है । केवल एक टीम वास्तव में प्रत्येक चाल के दौरान अपने खिलाड़ियों को स्थानांतरित करने के लिए मिलती है। वह टीम रेड से ब्लू तक आगे और पीछे चलती है, इसलिए प्रत्येक टीम कुल 1024 चालें बनाती है (जब तक कि खेल जल्दी समाप्त नहीं होता)।

टीम जो पहले स्थानांतरित होती है वह एक विकल्प है जिसे आपको नियंत्रक में सेट करना होगा।
जब लड़ाई ऑटोरन होती है, तो जो टीम हर लड़ाई में पहले विकल्प को आगे बढ़ाती है।

प्लेयर मूव्स

जब एक टीम चलती है, तो उस टीम के सभी खिलाड़ियों को खुद को स्थानांतरित करने के लिए कहा जाता है। ये कॉल प्रत्येक चाल के लिए पूरी तरह से यादृच्छिक क्रम में किए जाते हैं। जब बुलाया जाता है, तो प्रत्येक खिलाड़ी को लड़ाई की स्थिति के बारे में डेटा दिया जाता है ताकि वे तय कर सकें कि किस रास्ते पर चलना है।

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

रेड टीम मूव करती है ब्लू टीम आरेख

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

यदि कोई खिलाड़ी युद्ध के मैदान से बाहर निकलने की कोशिश करता है, या बहुत लंबा निर्णय लेता है कि किस रास्ते पर चलना है, या किसी तरह की त्रुटि है, तो वे स्वचालित रूप से स्थिर रहेंगे।

घूमने के अलावा, एक मोड़ के दौरान एक खिलाड़ी अपने साथियों द्वारा लिखित संदेश पढ़ सकता है और ऐसे संदेश लिख सकता है जो बदले में पढ़े जा सकते हैं। यह टीम संचार के कच्चे रूप के लिए अनुमति देता है।

कोड जो आप एक उत्तर के रूप में प्रस्तुत करते हैं, वह तर्क है जो आपके खिलाड़ी को स्थानांतरित करने का तरीका निर्धारित करता है और क्या संदेश पढ़ना और लिखना है ( "उत्तर कैसे दें" देखें )।

दुश्मन के खिलाड़ियों को हटाना

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

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

एक लड़ाई जीतना

एक बार लड़ाई शुरू हो जाती है जब सभी 2048 चालें चली जाती हैं या जब एक टीम में कोई खिलाड़ी नहीं बचता है। जीवित खिलाड़ियों की सबसे बड़ी संख्या वाली टीम जीतती है। यह एक टाई है यदि दोनों टीमों में जीवित खिलाड़ियों की संख्या समान है।

कैसे जवाब दें

आपके उत्तर में, आपको जावास्क्रिप्ट कोड प्रदान करने की आवश्यकता है जो यह तय करता है कि ऐसा करने पर आपका पिक्सेल किस रास्ते पर जाएगा।

में पहले अपने जवाब (लोगों को 4 स्थानों के साथ उपसर्ग) में दांतेदार कोड नमूना, इस कार्य के लिए एक शरीर बारे में:

function moveMe(move, x, y, tCount, eCount, tNear, eNear, setMsg, getMsg) {
    //the body goes here
}

अपने कोड को गोल्फ करने की कोई आवश्यकता नहीं है।

क्या लौटना है?

फ़ंक्शन का रिटर्न मान यह निर्धारित करता है कि आपका पिक्सेल किस ओर जाता है:

0
1रेड टीम के लिए सही स्थानांतरित करने के लिए अभी भी बने रहने के लिए, ब्लू टीम के
2लिए नीचे जाने के लिए रेड टीम के लिए बाईं ओर, ब्लू टीम
3के लिए तिरछे ऊपर
4जाने के लिए और तिरछे स्थानांतरित करने के लिए दाएं और
5तिरछे नीचे
6जाने के लिए छोड़ दिया और तिरछे स्थानांतरित करने के लिए छोड़ दिया सही और सही

आरेख के रूप में:

मूव रिटर्न वैल्यू आरेख

यदि आपका कोड इनमें से कोई भी काम करता है, तो आपका पिक्सेल डिफ़ॉल्ट रूप से बना रहेगा:

  • 0 से 6 तक पूर्णांक के अलावा कुछ भी देता है।
  • युद्ध के मैदान से पिक्सेल को बाहर निकालने का प्रयास।
  • चलाने के लिए 15 मिलीसेकंड से अधिक समय लगता है।
  • किसी भी प्रकार के अपवाद को फेंकता है।

आपके प्रवेश को निर्धारक होने की आवश्यकता नहीं है; उपयोग Math.randomठीक है।

पैरामीटर्स

moveMeलड़ाई की स्थिति के बारे में जानकारी देने के पहले 7 फ़ंक्शन पैरामीटर :

  • move एक पूर्णांक है जो 1 पर शुरू होता है और हर कदम के बाद वृद्धि होती है जब तक कि यह आपकी टीम के अंतिम कदम पर 1024 नहीं है।
  • x आपका वर्तमान x स्थान है, 0 (बायीं ओर) से 127 (सबसे दाएं) का पूर्णांक।
  • y आपकी वर्तमान y स्थिति, 0 (शीर्षतम) से 127 (बॉटलमोस्ट) पर पूर्णांक है।
  • tCount आपकी टीम में जीवित खिलाड़ियों की वर्तमान कुल संख्या है।
  • eCount दुश्मन टीम पर जीवित खिलाड़ियों की वर्तमान कुल संख्या है।
  • tNearआपकी टीम के उन बचे हुए खिलाड़ियों की सूची है जो 16 पिक्सेल से कम दूरी पर हैं (यूक्लिडियन दूरी)। के प्रत्येक तत्व tNearके साथ एक वस्तु है x, yऔर idगुण:
    • x दूसरे खिलाड़ी की x स्थिति है
    • y अन्य खिलाड़ी की y स्थिति है
    • id PPCG उपयोगकर्ता आईडी दूसरे खिलाड़ी की संख्या है (पूर्णांक के रूप में)
  • eNearबिल्कुल वैसा ही है जैसे tNearकि यह पास के दुश्मन खिलाड़ियों की सूची है, न कि टीम के साथी।

स्निपेट में वृत्त प्रत्येक खिलाड़ी के हैं tNearऔर eNearसीमा है।

संदेश

पिछले 2 मापदंडों, setMsgऔर getMsg, थोड़ा अलग उद्देश्य हैं।

एक लड़ाई के दौरान, प्रत्येक खिलाड़ी के पास 64 अक्षरों तक का एक तार होता है जिसे वे डेटा को संग्रहीत करने के लिए हर चाल के दौरान हेरफेर कर सकते हैं और संभावित रूप से अपने साथियों के साथ संवाद कर सकते हैं। प्रत्येक खिलाड़ी का स्ट्रिंग खाली स्ट्रिंग के रूप में बाहर शुरू होता है। जब एक खिलाड़ी को लड़ाई से हटा दिया जाता है, तो उनकी स्ट्रिंग "X" पर सेट हो जाती है।

  • setMsg एक तर्क फ़ंक्शन है जो आपके स्ट्रिंग को पास किए गए स्ट्रिंग पर सेट करता है।
    • यदि इसमें दिया गया मान स्ट्रिंग नहीं है, तो आपका स्ट्रिंग नहीं बदलता है।
    • यदि मान 64 से अधिक वर्णों वाला एक स्ट्रिंग है, तो केवल पहले 64 रखे जाते हैं।
  • getMsg एक तर्क फ़ंक्शन है जो आपकी टीम के किसी व्यक्ति का पीपीसीजी उपयोगकर्ता आईडी नंबर (पूर्णांक के रूप में) लेता है और उनकी स्ट्रिंग लौटाता है।
    • वह खिलाड़ी ग्रिड में कहीं भी हो सकता है। उन्हें आपके 16 पिक्सेल के दायरे में रहने की आवश्यकता नहीं है।
    • undefined दी गई आईडी नहीं मिलने पर वापस कर दी जाती है।

उदाहरण प्रस्तुत करना

यह खिलाड़ी ऊपर उठता है और दायाँ होता है अगर कोई दुश्मन बाईं ओर है, या फिर नीचे और बाएँ है अगर ID 123 के साथ टीममेट कहता है, लेकिन अन्यथा अभी भी रुकता है:

for (var i = 0; i < eNear.length; i++) {
    if (eNear[i].x === x - 1)
        return 3
}
if (getMsg(123) === 'move down and left')
    return 5
return 0

ध्यान दें कि यह कोड ब्लॉक सभी आवश्यक है। फ़ंक्शन की परिभाषा और कोष्ठक मौजूद नहीं होने चाहिए।

नियम और अयोग्यता

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

महत्वपूर्ण नियम

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

    आप विशेष अनुमति के बिना अपने उत्तर को हटा और हटा नहीं सकते हैं। मैं इसे दे दूंगा अगर कोई अनजाने में 8 घंटे के निशान या उसके बाद आपके पोस्ट को संपादित करता है, लेकिन सिर्फ इसलिए कि आपको बग नहीं मिला।

    यदि आप अपनी पोस्ट हटाते हैं और इसे हटाना रद्द करते हैं, तो संपादन नियम अभी भी लागू होता है। (नियंत्रक हटाए गए उत्तर नहीं देख सकता है।)

  2. एक नया जावास्क्रिप्ट चर घोषित करते समय, आपको varकीवर्ड का उपयोग करना चाहिए ।
    ऐसा इसलिए है क्योंकि बिना घोषित किया गया एक वैरिएबल varस्थानीय के बजाय वैश्विक हो जाता है, इसलिए नियंत्रक के साथ गलती से (या जानबूझकर) गड़बड़ करना या अन्य खिलाड़ियों के साथ स्वतंत्र रूप से संवाद करना आसान होगा। यह स्पष्ट करना होगा कि आप धोखा देने की कोशिश नहीं कर रहे हैं।

    फ़ंक्शंस की घोषणा करते समय varकीवर्ड का उपयोग करना सबसे अच्छा है । के var f = function(...) {...}बजाय का उपयोग करें function f(...) {...}। मुझे पूरी तरह से यकीन नहीं है कि क्यों, लेकिन कभी-कभी यह एक फर्क पड़ता है।

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

स्वचालित अयोग्यताएं

नियंत्रक ने इन कारणों से स्वचालित रूप से प्रविष्टियाँ अयोग्य घोषित कर दी हैं:

  • उपयोगकर्ता पहले ही उत्तर दे चुका है।
  • निर्माण के 8 घंटे से अधिक बाद संपादन किया गया था।
  • उपयोगकर्ता को विशेष रूप से अयोग्य घोषित किया गया है।

अन्य नियम

आपके कोड में आप नहीं हो सकते हैं ...

  • नियंत्रक या अन्य खिलाड़ी के कोड को एक्सेस या संशोधित करने का प्रयास।
  • जावास्क्रिप्ट में निर्मित कुछ भी संशोधित करने का प्रयास।
  • का उपयोग करके getMsgऔर को छोड़कर अन्य खिलाड़ियों के साथ संवाद करने का प्रयास setMsg
  • वेब सवाल करें।
  • अन्यथा दुर्भावनापूर्ण बातें करें।

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

आपकी टीम के साथ सहयोग और योजना के लिए आपका स्वागत है, लेकिन प्रतियोगिता को अनुकूल और नैतिक बनाए रखें।

यदि आपको लगता है कि किसी को अयोग्य घोषित करने की आवश्यकता है या आपको लगता है कि आपने अयोग्य घोषित कर दिया था, तो मेरे लिए एक टिप्पणी छोड़ दो या प्रश्न विशेष चैट में । मैं प्रतियोगिता में भाग नहीं ले रहा हूं।

सुझाए गए उत्तर प्रारूप

#[team color] Team - [entry title]

    //function body
    //probably on multiple lines

Explanations, notes, etc.

प्रविष्टि शीर्षक एक वैकल्पिक नाम है जिसे आप चाहें तो दे सकते हैं। नियंत्रक इसके साथ कुछ भी नहीं करता है।

स्कोरिंग

यह प्रतियोगिता आधिकारिक रूप से 19 अप्रैल, 2015 को समाप्त हो जाएगी। उस दिन (लगभग 11 बजे यूटीसी) मैं कम से कम 100 लड़ाइयों को अंजाम दूंगा। जो टीम सबसे अधिक जीतती है, वह समग्र विजेता होगी। यदि यह एक टाई या बेहद करीबी है, तो मैं और लड़ाइयाँ चलाऊंगा जब तक यह स्पष्ट न हो जाए कि एक टीम को फायदा है।

(विजेता के निर्णय के बाद आप जवाब दे सकते हैं, लेकिन मैं आधिकारिक परिणाम नहीं बदलूंगा।)

मैं उन्हें विंडोज 8.1 64-बिट, 4 जीबी रैम और 1.6 गीगाहर्ट्ज़ क्वाड कोर प्रोसेसर वाले लैपटॉप पर Google क्रोम के नवीनतम संस्करण में चला रहा हूं। सुनिश्चित करें कि आपका जावास्क्रिप्ट क्रोम में काम करता है।

जीत मुख्य रूप से टीम के गौरव के बारे में है, लेकिन मैं विजेता टीम पर सबसे ज्यादा वोट देने वाले जवाब को स्वीकार करूंगा।

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

सुझाव:

  • जवाब देने से पहले आप प्रविष्टियों का परीक्षण कर सकते हैं। स्टैक स्निपेट के निचले भाग के पास "टेस्ट एंट्री" टेक्स्टबॉक्स को संपादित करें और "टेस्ट एंट्री के साथ रीलोड" पर क्लिक करें। यदि यह खाली नहीं है, तो यह निर्दिष्ट टीम पर एक खिलाड़ी बन जाता है।
  • उत्तर एक नकाबपोश दायरे में चलाए जाते हैं, इसलिए चीजें पसंद होती हैं alertऔर console.logकाम नहीं करेंगी। consoleवस्तु केवल परीक्षण प्रविष्टि में इस्तेमाल किया जा सकता है।
  • स्टैक स्निपेट के निचले भाग में "डिबग संदेश" जांचें और अपने ब्राउज़र के कंसोल (F12) को देखें। जब लड़ाइयाँ चल रही हों तो लॉट्स ऑफ़ उपयोगी जानकारी छपी है।
  • आप मेटा सैंडबॉक्स पोस्ट का उपयोग एक प्रकार के मंचन क्षेत्र के रूप में कर सकते हैं । वहाँ जवाब निश्चित रूप से यहाँ से अलग हैं, और वहाँ नियंत्रक तारीख से बाहर हो सकता है।
  • चूंकि यह एक आधिकारिक स्टैक ऐप नहीं है , इसलिए यदि आप इसे एक दिन में 300 से अधिक बार पुनरारंभ करते हैं, तो नियंत्रक आपके लिए उत्तर लोड करना बंद कर सकता है।

इस चुनौती की "अगली कड़ी": ब्लॉक बिल्डिंग बॉट फ्लक्स!

त्वरित सम्पक

फिडेल कंट्रोलर    फुलस्क्रीन    जनरल चैट    रेड चैट    (ब्लू चैट?)    सैंडबॉक्सपोस्ट


51
आप यह सब एक साथ डाल एक बहुत बढ़िया काम किया।
एलेक्स ए।

6
हर कोई, कृपया गैर-महत्वपूर्ण टिप्पणियों के लिए चैट का उपयोग करें ।
केल्विन के

4
रेड टीम इस चैट रूम में समन्वय कर रही है: chat.stackexchange.com/rooms/22548/…
एडम डेविस

5
मेरी मदद करो, मैं इस के साथ प्यार में हूँ। कृपया अपने द्वारा पहचाने जाने वाले हर एक डेवलपर तक इस शब्द का प्रसार करें।
Hylianpuffball

3
@ हेलकाहोम्बा हाय्या! बस आपको यह बताना चाहता था कि समुदाय के कुछ उत्तरों ने उन्हें अयोग्य घोषित कर दिया था।
स्टीफन

जवाबों:


52

ब्लू टीम - SphiNotPi3000

// Char 0: top or bottom ("T" or "B")
// Char 1, 2: x/y coords
// Char 3, move polarity
// Char 4: offset (as codepoint - 128)

var twin = 21487;
var myself = 2867;
var formpos = "T";

var tochar = String.fromCharCode;
var movestat = (move % 2).toString();

var inbox = getMsg(twin);

// Spoofing the message of a deceased partner
if (inbox == "X"){
    inbox = "B" + tochar(x) + tochar(y+1) + ((move + 1) % 2).toString() + tochar(0);
}

var selfsafe = [9,10,10,10,10,10,10];

// Remove useless edge moves
if (x == 0){
    selfsafe[4] = 0;
    selfsafe[5] = 0;
}
if (x == 127){
    selfsafe[3] = 0;
    selfsafe[6] = 0;
}
if (y == 0){
    selfsafe[2] = 0;
    selfsafe[3] = 0;
    selfsafe[4] = 0;
}
if (y == 127){
    selfsafe[1] = 0;
    selfsafe[6] = 0;
    selfsafe[5] = 0;
}

var selfdisp = [[0,0],[0,1],[0,-1],[1,-1],[-1,-1],[-1,1],[1,1]];

if (inbox == "") {
    // First move, pick anywhere safe

    for (j = 0; j < 7; j++) {
        for (var i = 0; i < eNear.length; i++){
            var enemy = eNear[i];
            var dx = enemy.x - x - selfdisp[j][0];
            var dy = enemy.y - y - selfdisp[j][1];

            if (dx * dx == 1 && dy >= -1 && dy <= 1) {
                selfsafe[j] = 0;
            }
        }

        if (selfsafe[j]) {
            var strpos = tochar(x + selfdisp[j][0]) + tochar(y + selfdisp[j][0]);
            var offset = tochar(Math.floor(Math.random() * 256));
            setMsg(formpos + strpos + movestat + offset);
            return j;
        }
    }

} else {
    var twinformpos = inbox.charAt(0);
    var twinx = inbox.charAt(1).charCodeAt();
    var twiny = inbox.charAt(2).charCodeAt();
    var twinmovestat = inbox.charAt(3);
    var offset = inbox.charAt(4);

    formpos = twinformpos == "T" ? "B" : "T";
    var targetx = twinx;
    var targety = formpos == "T" ? (twiny - 1) : (twiny + 1);

    // If true, then this bot is either the second one to move or is not in position.  Move into position.
    if (twinmovestat == movestat || x != targetx || y != targety) {
        var bestmove = 0;

        for (var j = 0; j < 7; j++) {
            for (var i = 0; i < eNear.length; i++){
                var enemy = eNear[i];
                var dx = enemy.x - x - selfdisp[j][0];
                var dy = enemy.y - y - selfdisp[j][1];

                if (dx * dx == 1 && dy >= -1 && dy <= 1) {
                    selfsafe[j] = 0;
                }
                if (dx == 0 && dy == 0){
                    selfsafe[j] *= 2;
                }
            }

            selfsafe[j] -= Math.abs(x + selfdisp[j][0] - targetx) + Math.abs(y + selfdisp[j][1] - targety);

            if (selfsafe[j] > selfsafe[bestmove]) {
                bestmove = j;
            }
        }

        var strpos = tochar(x + selfdisp[bestmove][0]) + tochar(y + selfdisp[bestmove][1]);
        setMsg(formpos + strpos + movestat + offset);
        return bestmove;

    } else {
        // In formation, and is the leader this turn

        var topy = formpos == "T" ? y : (y - 1);
        var topx = x;
        var safe = [1,1,1,1,1,1,1,1,1];
        var disp = [[0,0],[0,1],[0,-1],[1,-1],[-1,-1],[-1,1],[1,1],[1,0],[-1,0]];
        var otherpos = formpos == "T" ? "B" : "T";

        // Avoid dangerous squares and always kill if safe to do so
        for (var j = 0; j < 9; j++){
            var ntopx = topx + disp[j][0];
            var ntopy = topy + disp[j][1];

            if (ntopx < 0 || ntopx > 127 || ntopy < 0 || ntopy > 126){
                safe[j] = 0;
                continue;
            }

            for (var i = 0; i < eNear.length; i++){
                var enemy = eNear[i];
                var dx = enemy.x - ntopx;
                var dy = enemy.y - ntopy;

                if(dx * dx == 1 && dy >= -1 && dy <= 2){
                    safe[j] = 0;
                    continue;
                }

                if(dx == 0 && dy >= 0 && dy <= 1){
                    // Kill!
                    var strpos = tochar(x + disp[j][0]) + tochar(y + disp[j][1]);

                    if (j > 6) {
                        setMsg(otherpos + strpos + movestat + offset);
                        if (formpos == "T"){return 13 - j;}
                        return j - 4;
                    }

                    setMsg(formpos + strpos + movestat + offset);
                    return j;
                }
            }
        }

        var pref = [];

        for (var i = 0; i < eNear.length; i++){
            var enemy = eNear[i];
            var dy = enemy.y - topy;
            var dx = enemy.x - topx;

            if (dy < 0 && dx == 0){ pref=[2,4,3,8,7,1,5,6,0]; }
            if (dy > 0 && dx == 0){ pref=[1,5,6,7,8,2,4,3,0]; }
            if (dy == 0 && dx > 0){ pref=[7,6,3,1,2,5,4,8,0]; }
            if (dy == 0 && dx < 0){ pref=[8,5,4,1,2,6,3,7,0]; }
            if (dy < 0 && dx < 0){ pref=[4,8,5,1,0,2,6,7,3]; }
            if (dy > 0 && dx < 0){ pref=[5,8,4,2,0,1,3,7,6]; }
            if (dy < 0 && dx > 0){ pref=[3,7,6,1,0,2,5,8,4]; }
            if (dy > 0 && dx > 0){ pref=[6,7,3,2,0,1,4,8,5]; }

            for (var k = 0; k < pref.length; k++)
            {
                if (safe[pref[k]]){
                    var strpos = tochar(x + disp[pref[k]][0]) + tochar(y + disp[pref[k]][1]);

                    if (pref[k] > 6) {
                        setMsg(otherpos + strpos + movestat + offset);
                        if(formpos == "T"){return 13 - pref[k];}
                        return pref[k] - 4;
                    }

                    setMsg(formpos + strpos + movestat + offset);
                    return pref[k];
                }
            }
        }

        var offsetint = offset.charCodeAt();
        var offsetmove = move - 128 + offsetint;

        if (offsetmove % 900 < 30) {
            var targetx = 64 - (offsetmove % 30);
            var targety = 64 - (offsetmove % 30);
        } else if (offsetmove % 900 < 90) {
            var targetx = 34 + ((offsetmove - 30) % 60);
            var targety = 34;
        } else if (offsetmove % 900 < 150) {
            var targetx = 94;
            var targety = 34 + ((offsetmove - 30) % 60);
        } else if (offsetmove % 900 < 210) {
            var targetx = 94 - ((offsetmove - 30) % 60);
            var targety = 94;
        } else if (offsetmove % 900 < 270) {
            var targetx = 34;
            var targety = 94 - ((offsetmove - 30) % 60);
        } else if (offsetmove % 900 < 300) {
            var targetx = 34 + (offsetmove % 30);
            var targety = 34 + (offsetmove % 30);
        } else if (offsetmove % 900 < 360) {
            var targetx = 64 + (offsetmove % 60);
            var targety = 64 - (offsetmove % 60);
        } else if (offsetmove % 900 < 480) {
            var targetx = 124;
            var targety = 4 + (offsetmove % 120);
        } else if (offsetmove % 900 < 600) {
            var targetx = 124 - (offsetmove % 120);
            var targety = 124;
        } else if (offsetmove % 900 < 720) {
            var targetx = 4;
            var targety = 124 - (offsetmove % 120);
        } else if (offsetmove % 900 < 840) {
            var targetx = 4 + (offsetmove % 120);
            var targety = 4;
        } else {
            var targetx = 124 - (offsetmove % 60);
            var targety = 4 + (offsetmove % 60);
        }

        if (offsetint % 4 == 1) {
            var temp = targetx;
            var targetx = 127 - targety;
            var targety = temp;
        } else if (offsetint % 4 == 2) {
            var targetx = 127 - targetx;
            var targety = 127 - targety;
        } else if (offsetint % 4 == 3) {
            var temp = targetx;
            var targetx = targety;
            var targety = 127 - temp;
        }

        if ((offsetint >> 3) % 2) {
            var targetx = 127 - targetx;
        }

        var bestmove = 0;

        for (var j = 0; j < 9; j++) {
            safe[j] -= Math.abs(topx + disp[j][0] - targetx) + Math.abs(topy + disp[j][1] - targety);

            if (safe[j] > safe[bestmove]) {
                bestmove = j;
            }
        }

        var strpos = tochar(x + disp[bestmove][0]) + tochar(y + disp[bestmove][1]);

        if (bestmove > 6) {
            setMsg(otherpos + strpos + movestat + offset);
            if (formpos == "T"){return 13 - bestmove;}
            return bestmove - 4;
        }

        setMsg(formpos + strpos + movestat + offset);
        return bestmove;
    }
}

यह बॉट Sp3000 के बॉट के साथ एक जोड़ा बनाता है ।

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

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

जब निष्क्रिय होता है, बॉट दुश्मनों की तलाश में बोर्ड के चारों ओर घूमता है। एक बार जब वे एक दुश्मन को हाजिर करते हैं, तो वे सावधानीपूर्वक खुद को हमला करने के लिए सही स्थिति में ले जाते हैं। एक बहुत ही साफ-सुथरी विशेषता है क्षैतिज रूप से सीधे स्थानांतरित करने की क्षमता, बॉट्स वैकल्पिक स्थान होने से हासिल की।


9
ओ प्यारे! जैसे ही वे एक जोड़ी बनाते हैं यह लाल रंग के लिए एक स्वचालित नुकसान है।
माइनस

@Minos बहुत ज्यादा, हाँ :)
Theonlygusti

मैंने लाल रंग के लिए एक समान बॉट लिखने के बारे में सोचा था, लेकिन पहले इसके आसपास नहीं मिला, अब मुझे एक रणनीति के साथ आना होगा जो जोड़ी को हरा सकता है।
लीख

रिकॉर्ड के लिए, मैंने देखा है कि ऐसी जगह है जहाँ varइस पोस्ट और Sp3000 का उपयोग नहीं किया गया है। वे jतुरंत 0 पर असाइन करते हैं और यह नियंत्रक के साथ बिल्कुल भी हस्तक्षेप नहीं करता है, इसलिए यह सौभाग्य से इस मामले में कोई समस्या नहीं है।
केल्विन के

47

ब्लू टीम - SphiNotPi3000

// Char 0: top or bottom ("T" or "B")
// Char 1, 2: x/y coords
// Char 3, move polarity
// Char 4: offset (as codepoint - 128)

var myself = 21487;
var twin = 2867;
var formpos = "B";

var tochar = String.fromCharCode;
var movestat = (move % 2).toString();

var inbox = getMsg(twin);

// Spoofing the message of a deceased partner
if (inbox == "X"){
    inbox = "B" + tochar(x) + tochar(y+1) + ((move + 1) % 2).toString() + tochar(0);
}

var selfsafe = [9,10,10,10,10,10,10];

// Remove useless edge moves
if (x == 0){
    selfsafe[4] = 0;
    selfsafe[5] = 0;
}
if (x == 127){
    selfsafe[3] = 0;
    selfsafe[6] = 0;
}
if (y == 0){
    selfsafe[2] = 0;
    selfsafe[3] = 0;
    selfsafe[4] = 0;
}
if (y == 127){
    selfsafe[1] = 0;
    selfsafe[6] = 0;
    selfsafe[5] = 0;
}

var selfdisp = [[0,0],[0,1],[0,-1],[1,-1],[-1,-1],[-1,1],[1,1]];

if (inbox == "") {
    // First move, pick anywhere safe

    for (j = 0; j < 7; j++) {
        for (var i = 0; i < eNear.length; i++){
            var enemy = eNear[i];
            var dx = enemy.x - x - selfdisp[j][0];
            var dy = enemy.y - y - selfdisp[j][1];

            if (dx * dx == 1 && dy >= -1 && dy <= 1) {
                selfsafe[j] = 0;
            }
        }

        if (selfsafe[j]) {
            var strpos = tochar(x + selfdisp[j][0]) + tochar(y + selfdisp[j][0]);
            var offset = tochar(Math.floor(Math.random() * 256));
            setMsg(formpos + strpos + movestat + offset);
            return j;
        }
    }

} else {
    var twinformpos = inbox.charAt(0);
    var twinx = inbox.charAt(1).charCodeAt();
    var twiny = inbox.charAt(2).charCodeAt();
    var twinmovestat = inbox.charAt(3);
    var offset = inbox.charAt(4);

    formpos = twinformpos == "T" ? "B" : "T";
    var targetx = twinx;
    var targety = formpos == "T" ? (twiny - 1) : (twiny + 1);

    // If true, then this bot is either the second one to move or is not in position.  Move into position.
    if (twinmovestat == movestat || x != targetx || y != targety) {
        var bestmove = 0;

        for (var j = 0; j < 7; j++) {
            for (var i = 0; i < eNear.length; i++){
                var enemy = eNear[i];
                var dx = enemy.x - x - selfdisp[j][0];
                var dy = enemy.y - y - selfdisp[j][1];

                if (dx * dx == 1 && dy >= -1 && dy <= 1) {
                    selfsafe[j] = 0;
                }
                if (dx == 0 && dy == 0){
                    selfsafe[j] *= 2;
                }
            }

            selfsafe[j] -= Math.abs(x + selfdisp[j][0] - targetx) + Math.abs(y + selfdisp[j][1] - targety);

            if (selfsafe[j] > selfsafe[bestmove]) {
                bestmove = j;
            }
        }

        var strpos = tochar(x + selfdisp[bestmove][0]) + tochar(y + selfdisp[bestmove][1]);
        setMsg(formpos + strpos + movestat + offset);
        return bestmove;

    } else {
        // In formation, and is the leader this turn

        var topy = formpos == "T" ? y : (y - 1);
        var topx = x;
        var safe = [1,1,1,1,1,1,1,1,1];
        var disp = [[0,0],[0,1],[0,-1],[1,-1],[-1,-1],[-1,1],[1,1],[1,0],[-1,0]];
        var otherpos = formpos == "T" ? "B" : "T";

        // Avoid dangerous squares and always kill if safe to do so
        for (var j = 0; j < 9; j++){
            var ntopx = topx + disp[j][0];
            var ntopy = topy + disp[j][1];

            if (ntopx < 0 || ntopx > 127 || ntopy < 0 || ntopy > 126){
                safe[j] = 0;
                continue;
            }

            for (var i = 0; i < eNear.length; i++){
                var enemy = eNear[i];
                var dx = enemy.x - ntopx;
                var dy = enemy.y - ntopy;

                if(dx * dx == 1 && dy >= -1 && dy <= 2){
                    safe[j] = 0;
                    continue;
                }

                if(dx == 0 && dy >= 0 && dy <= 1){
                    // Kill!
                    var strpos = tochar(x + disp[j][0]) + tochar(y + disp[j][1]);

                    if (j > 6) {
                        setMsg(otherpos + strpos + movestat + offset);
                        if (formpos == "T"){return 13 - j;}
                        return j - 4;
                    }

                    setMsg(formpos + strpos + movestat + offset);
                    return j;
                }
            }
        }

        var pref = [];

        for (var i = 0; i < eNear.length; i++){
            var enemy = eNear[i];
            var dy = enemy.y - topy;
            var dx = enemy.x - topx;

            if (dy < 0 && dx == 0){ pref=[2,4,3,8,7,1,5,6,0]; }
            if (dy > 0 && dx == 0){ pref=[1,5,6,7,8,2,4,3,0]; }
            if (dy == 0 && dx > 0){ pref=[7,6,3,1,2,5,4,8,0]; }
            if (dy == 0 && dx < 0){ pref=[8,5,4,1,2,6,3,7,0]; }
            if (dy < 0 && dx < 0){ pref=[4,8,5,1,0,2,6,7,3]; }
            if (dy > 0 && dx < 0){ pref=[5,8,4,2,0,1,3,7,6]; }
            if (dy < 0 && dx > 0){ pref=[3,7,6,1,0,2,5,8,4]; }
            if (dy > 0 && dx > 0){ pref=[6,7,3,2,0,1,4,8,5]; }

            for (var k = 0; k < pref.length; k++)
            {
                if (safe[pref[k]]){
                    var strpos = tochar(x + disp[pref[k]][0]) + tochar(y + disp[pref[k]][1]);

                    if (pref[k] > 6) {
                        setMsg(otherpos + strpos + movestat + offset);
                        if(formpos == "T"){return 13 - pref[k];}
                        return pref[k] - 4;
                    }

                    setMsg(formpos + strpos + movestat + offset);
                    return pref[k];
                }
            }
        }

        var offsetint = offset.charCodeAt();
        var offsetmove = move - 128 + offsetint;

        if (offsetmove % 900 < 30) {
            var targetx = 64 - (offsetmove % 30);
            var targety = 64 - (offsetmove % 30);
        } else if (offsetmove % 900 < 90) {
            var targetx = 34 + ((offsetmove - 30) % 60);
            var targety = 34;
        } else if (offsetmove % 900 < 150) {
            var targetx = 94;
            var targety = 34 + ((offsetmove - 30) % 60);
        } else if (offsetmove % 900 < 210) {
            var targetx = 94 - ((offsetmove - 30) % 60);
            var targety = 94;
        } else if (offsetmove % 900 < 270) {
            var targetx = 34;
            var targety = 94 - ((offsetmove - 30) % 60);
        } else if (offsetmove % 900 < 300) {
            var targetx = 34 + (offsetmove % 30);
            var targety = 34 + (offsetmove % 30);
        } else if (offsetmove % 900 < 360) {
            var targetx = 64 + (offsetmove % 60);
            var targety = 64 - (offsetmove % 60);
        } else if (offsetmove % 900 < 480) {
            var targetx = 124;
            var targety = 4 + (offsetmove % 120);
        } else if (offsetmove % 900 < 600) {
            var targetx = 124 - (offsetmove % 120);
            var targety = 124;
        } else if (offsetmove % 900 < 720) {
            var targetx = 4;
            var targety = 124 - (offsetmove % 120);
        } else if (offsetmove % 900 < 840) {
            var targetx = 4 + (offsetmove % 120);
            var targety = 4;
        } else {
            var targetx = 124 - (offsetmove % 60);
            var targety = 4 + (offsetmove % 60);
        }

        if (offsetint % 4 == 1) {
            var temp = targetx;
            var targetx = 127 - targety;
            var targety = temp;
        } else if (offsetint % 4 == 2) {
            var targetx = 127 - targetx;
            var targety = 127 - targety;
        } else if (offsetint % 4 == 3) {
            var temp = targetx;
            var targetx = targety;
            var targety = 127 - temp;
        }

        if ((offsetint >> 3) % 2) {
            var targetx = 127 - targetx;
        }

        var bestmove = 0;

        for (var j = 0; j < 9; j++) {
            safe[j] -= Math.abs(topx + disp[j][0] - targetx) + Math.abs(topy + disp[j][1] - targety);

            if (safe[j] > safe[bestmove]) {
                bestmove = j;
            }
        }

        var strpos = tochar(x + disp[bestmove][0]) + tochar(y + disp[bestmove][1]);

        if (bestmove > 6) {
            setMsg(otherpos + strpos + movestat + offset);
            if (formpos == "T"){return 13 - bestmove;}
            return bestmove - 4;
        }

        setMsg(formpos + strpos + movestat + offset);
        return bestmove;
    }
}

यह बॉट फ़िनोटपी के बॉट के साथ एक जोड़ा बनाता है । हमारी रणनीति की संक्षिप्त व्याख्या के लिए Phi की पोस्ट देखें।


आउच! अच्छा एक ..
डबलडबल

21

रेड टीम - सीकरबोट

var myself = 38926;
var messages = getMsg(myself).split(';');
var minimalDistanceToFriend = 2;
var chosenMove = null;
var newDistanceToFriend = null;
var minimalVerticalDistanceToEnemy = null, minimalHorizontalDistanceToEnemy = null;
var closestFriend = null;
var closestEnemy = null;
var possibleVictims = [];
var possibleMoves = [
    {newX: x, newY: y},
    {newX: x + 1, newY: y},
    {newX: x - 1, newY: y},
    {newX: x + 1, newY: y - 1},
    {newX: x - 1, newY: y - 1},
    {newX: x - 1, newY: y + 1},
    {newX: x + 1, newY: y + 1}
];

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

var iAmInDanger = function(meX, meY, himX, himY) {
    return (Math.abs(meY - himY) === 1 && Math.abs(meX - himX) <= 1);
};

var iCanKillHim = function(meX, meY, himX, himY) {
    return (Math.abs(meX - himX) === 1 && Math.abs(meY - himY) <= 1);
};

var setMessage = function() {
    messages[0] = ("000" + x).substr(-3, 3);
    messages[1] = ("000" + y).substr(-3, 3);
    setMsg(messages.join(';'));
}

for (i = 0; i < possibleMoves.length; i++) {
    if (possibleMoves[i].newX < 0 || possibleMoves[i].newY < 0 || possibleMoves[i].newX > 127 || possibleMoves[i].newY > 127) {
        possibleMoves[i] = null;
    }
}

for (var i = 0; i < eNear.length; i++) {
    if (closestEnemy === null || calculateDistance(x, y, closestEnemy.x, closestEnemy.y) > calculateDistance(x, y, eNear[i].x, eNear[i].y)) {
        closestEnemy = eNear[i];
    }
    if (Math.abs(x - eNear[i].x) <= 2 && Math.abs(y - eNear[i].y) <= 2) {
        possibleVictims.push(eNear[i]);
    }
}

for (i = 0; i < tNear.length; i++) {
    if (closestFriend === null || calculateDistance(x, y, closestFriend.x, closestFriend.y) > calculateDistance(x, y, tNear[i].x, tNear[i].y)) {
        closestFriend = tNear[i];
    }
}    

for (i = 0; i < possibleMoves.length; i++) {
    for (var j = 0; j < possibleVictims.length; j++) {
        if (possibleMoves[i] !== null && iAmInDanger(possibleMoves[i].newX, possibleMoves[i].newY, possibleVictims[j].x, possibleVictims[j].y)) {
            possibleMoves[i] = null;
        }
    }
}

for (i = 0; i < possibleMoves.length; i++) {
    for (j = 0; j < possibleVictims.length; j++) {
        if (possibleMoves[i] !== null && possibleMoves[i].newX === possibleVictims[j].x && possibleMoves[i].newY === possibleVictims[j].y) {
            messages[2] = 0;
            setMessage();
            return i;
        }
    }
}

if (possibleVictims.length > 0) {
    if (iAmInDanger(x, y, possibleVictims[0].x, possibleVictims[0].y)) {
        if (closestFriend !== null) {
            for (i = 0; i < possibleMoves.length; i++) {
                if (possibleMoves[i] !== null) {
                    var distance = calculateDistance(possibleMoves[i].newX, possibleMoves[i].newY, closestFriend.x, closestFriend.y);
                    if (newDistanceToFriend === null || (distance < newDistanceToFriend && distance >= minimalDistanceToFriend)) {
                        newDistanceToFriend = distance;
                        chosenMove = i;
                    }
                }
            }
            messages[2] = 0;
            setMessage();
            return chosenMove;
        }
        else {
            var aggressiveMoves = [];
            var randomMoves = [];

            for (i = 0; i < possibleMoves.length; i++) {
                if (possibleMoves[i] !== null) {
                    if (iCanKillHim(possibleMoves[i].newX, possibleMoves[i].newY, possibleVictims[0].x, possibleVictims[0].y)) {
                        aggressiveMoves.push(i);
                    }
                    randomMoves.push(i);
                }
            }
            var approachCount = messages[2] || 0;
            if (approachCount < 5 && aggressiveMoves.length > 0) {
                messages[2] = approachCount + 1;
                chosenMove = aggressiveMoves[Math.floor(Math.random() * aggressiveMoves.length)];
                setMessage();
                return chosenMove;
            } 
            else {
                chosenMove = randomMoves[Math.floor(Math.random() * randomMoves.length)];
                setMessage();
                return chosenMove;
            }
        }
    }
}

if (closestEnemy != null) {
    for (i = 1; i < possibleMoves.length; i++) {
        if (possibleMoves[i] !== null) {
            var verticalDistance = Math.abs(possibleMoves[i].newY - closestEnemy.y);
            var horizontalDistance = Math.abs(possibleMoves[i].newX - closestEnemy.x);
            if (minimalVerticalDistanceToEnemy === null || verticalDistance <= minimalVerticalDistanceToEnemy) {
                if (minimalVerticalDistanceToEnemy !== null && verticalDistance === minimalVerticalDistanceToEnemy) {
                    if (minimalHorizontalDistanceToEnemy === null || horizontalDistance <= minimalHorizontalDistanceToEnemy) {
                        minimalHorizontalDistanceToEnemy = horizontalDistance;
                        chosenMove = i;
                    }
                }
                else {
                    minimalVerticalDistanceToEnemy = verticalDistance;
                    minimalHorizontalDistanceToEnemy = horizontalDistance;
                    chosenMove = i;
                }                                        
            }
        }            
    }
    messages[2] = 0;
    setMessage();
    return chosenMove;
}

var seekStatus = messages[3] || 0;
var seekCount = messages[4] || 0;
seekStatus = parseInt(seekStatus, 10);
seekCount = parseInt(seekCount, 10);

switch (seekStatus) {
    case 0:
        if (x < 16) {
            seekCount = 0;
            if (y > 111) {
                seekStatus = 4;
            }
            else {
                seekStatus = 1;
            }                
        }
        else {
            chosenMove = 2;
        }
        break;
    case 1:
        seekCount++;
        if (y > 111 || seekCount > 31) {
            seekStatus = 2;
        }            
        else {
            if (seekCount % 2 === 0) {
                chosenMove = 5;
            }
            else {
                chosenMove = 6;
            }
        }
        break;
    case 2:
        if (x > 111) {
            seekCount = 0;
            if (y > 111) {
                seekStatus = 4;
            }
            else {
                seekStatus = 3;
            }                   
        }
        else {
            chosenMove = 1;
        }
        break;
    case 3:
        seekCount++;
        if (y > 111 || seekCount > 31) {
            seekStatus = 0;
        }
        else {
            if (seekCount % 2 === 0) {
                chosenMove = 5;
            }
            else {
                chosenMove = 6;
            }
        }
        break;
    case 4:
        seekCount++;
        if (y < 16) {
            if (x > 63) {
                seekStatus = 0;
            }
            else {
                seekStatus = 2;
            }
        }
        else {
            if (seekCount % 2 === 0) {
                chosenMove = 3;
            }
            else {
                chosenMove = 4;
            }
        }
        break;
}

messages[2] = 0;
messages[3] = seekStatus;
messages[4] = seekCount;    

setMessage();
return chosenMove;

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

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

अगर सीकरबॉट किसी दुश्मन को मार देता है, तो वह उसकी ओर बढ़ जाएगा। यदि यह दुश्मन को मार सकता है, तो यह तब तक करेगा जब तक कि चाल बच जाती है।

यदि यह किसी दुश्मन को मार नहीं सकता है, लेकिन दुश्मन इसे अपने अगले मोड़ पर मारने की स्थिति में है, तो सीकरबॉट दुश्मन को दोस्त की ओर लुभाने की कोशिश करेगा (यदि कोई दिखाई दे तो)। यदि कोई टीम सदस्य देखने में नहीं है, तो यह एक स्थिति में जाने की कोशिश करेगा, जहां यह अगली बारी में दुश्मन को मार सकता है। यदि यह एक पंक्ति में 5 बार काम नहीं करता है, तो यह रणनीति को बदल देगा और एक यादृच्छिक पैटर्न में चलना शुरू कर देगा, संभवतः अगले दौर में दुश्मन पर फिर से बंद करना।

इसके लायक होने के लिए, यह "x; y" (जहाँ x और y शून्य गद्देदार हैं) प्रारूप में अपनी स्थिति चिल्लाने के लिए संदेश के पहले 7 अक्षरों का उपयोग करेगा।

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



2
आपने हर बार इसे जीतने के बाद लाल टीम को जीत दिलाई है। यह देखने के लिए दिलचस्प होगा कि दो नए नीले बॉट एक बार गिरोह बनाते हैं।
एडम डेविस

इस वध को ब्लूज़ देखने में बहुत मज़ा आता है :)
TheNumberOne

@AdamDavis उन दो नीले बॉट्स का समन्वय पागल है; हर खेल मैंने देखा है अब तक वे पिटाई कर चुके हैं!
Theonlygusti

12

रेड टीम - ग्रूमबा

// v009
// I exist, therefore I am identifiable and have motivation
var myself = 1686;
var motive = [ 4,4, 4,-1, 4,3, 3,-1, 
               3,3, 3,1, 1,1, 6,1,
               6,6, 6,-2, 6,5, 5,-2,
               5,5, 5,2, 2,2, 4,2]; 
var killzone = [4,2,5, 3,1,6];

// Default move is to not move.  Then we consider each task in lowest
// to highest priority.  Each task only modifies the move if it needs to.
var move = 0;
var vector = 0;
var step = 0;

// Restore internal state from message
var selfMessage;
selfMessage = getMsg(myself);
if(selfMessage === undefined || selfMessage.length > 2) // first run or bigger than 99, let's make some defaults!
{
   // vector, step - let the default above stand
}
else
{
   vector = Math.floor(parseInt(selfMessage)/2) % 16;
   step = parseInt(selfMessage) % 2;
}

// 1) Move according to motivation
move = motive[vector*2 + step];
step = (step + 1) % 2;

if(move == -1)
{
   move = Math.floor(Math.random() * 2) + 3;
}

if(move == -2)
{
   move = Math.floor(Math.random() * 2) + 5;
}

// 2) When interacting with a wall, rebound but alter the angle 
//    slightly so as to prevent trivial counterattack strategies
// If we are close to a wall and headed towards that wall, randomly
// choose another vector to follow.
if((y < 8 && (vector > 14 || vector < 6)) ||
   (y > 120 && (vector > 6 && vector < 14)) ||
   (x < 8 && (vector > 10 || vector < 2)) ||
   (x > 120 && (vector > 2 && vector < 10)))
{
   vector = Math.floor(Math.random() * 16);
}

// When an enemy is within view, move beside them

if(eNear.length > 0) // I only look at the first enemy in the array.
{
    enemy = eNear[0];
    if(enemy.x == x) // Don't want to be directly on top or below
    {
       if(enemy.y > y) // If they are below move angular down
       {
           move = (x > 63) ? 5 : 6;
       }
       else
       {
           move = (x > 63) ? 4 : 3;
       }
       move = 1;
    }
    else if(enemy.y > y)
    {
       if(enemy.x > x)
       {
           move = 6;
       }
       else
       {
           move = 5;
       }
       vector = 10;
    }
    else if(enemy.y != y)
    {
       if(enemy.x > x)
       {
           move = 3;
       }
       else
       {
           move = 4;
       }
        vector = 2;
    }
    else
    {
        if(enemy.x > x)
        {
            move = 1;
            vector = 6
        }
        else
        {
            move = 2;
            vector = 14;
        }
    }
}

// 3) When an enemy is one space away, act or react.
//    A) If it can be consumed, consume
//    B) If it can consume us next turn, evade
//    C) If we can reposition ourselves to consume next turn, reposition

var enemy;
var difx;
var dify;

// Evade
for(var i=0; i<eNear.length; i++) {
    enemy = eNear[i];
    if(enemy.x == x && enemy.y == y + 1)
    {
       if(x>63)
       {
           move = 5;
       }
       else
       {
           move = 6;
       }
    }
    if(enemy.x == x && enemy.y == y - 1)
    {
       if(x>63)
       {
           move = 4;
       }
       else
       {
           move = 3;
       }
    }
}

// Kill
for(var i=0; i<eNear.length; i++) {
    enemy = eNear[i];
    difx = enemy.x - x + 1;
    dify = enemy.y - y + 1;
    if((difx == 0 || difx == 2) && (dify > -1 && dify < 3))
    {
       move = killzone[Math.floor(difx/2) * 3 + dify];
    }
}

// 4) Encode the current surroundings and internal state
var value = vector*2+step
var message = value.toString();
setMsg(message);

// Return move
return move;

टिप्पणियों में नोट्स।


3
उपयोग न करें self। वह चर इंगित करने के लिए आरक्षित है window.self। का प्रयोग करें I(राजधानी i) के बजाय। या me। या भी myself
इस्माईल मिगुएल

11

रेड टीम - आलसी कातिलों

var moves={
    '-1':{'-1':4,'0':0,'1':3},
    '0':{'-1':2,'0':0,'1':1},
    '1':{'-1':5,'0':0,'1':6}
},$id=14732,to,enemies='';

for(var k in eNear)
{
    enemies+=String.fromCharCode(eNear[k].x+32)+String.fromCharCode(eNear[k].y+32);
}

enemies=enemies.replace('"','\\"');

for(var k in eNear)
{
    to=undefined;
    switch( eNear[k].x - x )
    {
        case -1:
        case 1:
            to=moves[eNear[k].y - y][eNear[k].x - x];
            break;
        case 0:
            to=moves[-(eNear[k].y - y)][0];
            break;
    }
    if(to!==undefined)
    {
        setMsg('"a":1,"o":['+x+','+y+'],"m":'+(to||0)+',"e":"'+enemies+'"');
        return to;
    }
}

var msg;

for(var k in tNear)
{
    if(msg = getMsg(tNear[k].id))
    {
        try
        {
            var m=JSON.parse('{'+msg+'}');
            if(m && m[$id])
            {
                if(m[$id].a === 1)
                {
                    if(!m[$id].x || !m[$id].y)
                    {
                        setMsg('"a":1,"o":['+x+','+y+'],"m":'+m[$id].m+',"id":'+m[$id].id+'}');
                        return m[$id].m;
                    }
                    else
                    {
                        setMsg('"a":1,"o":['+x+','+y+'],"m":{"x":'+m[$id].x+',"y":'+m[$id].y+'},"id":'+m[$id].id+',"e":"'+enemies+'"');
                        return moves[m[$id].x][m[$id].y];
                    }
                }
                else if(m[$id].a === 0)
                {
                    setMsg('"a":0,"o":['+x+','+y+'],"m":0,"id":'+m[$id].id+',"e":"'+enemies+'"');
                    return moves[m[$id].x||0][m[$id].y||0];
                }
            }
        }
        catch(e){}
    }
}

setMsg('"a":0,"o":['+x+','+y+'],"m":0,"e":"'+enemies+'"');
return 0;

यह सबसे बुनियादी है जो मुझे मिल सकता है। यह अब 100% बुनियादी नहीं है।

यह केवल IF REQUIRED चलता है

यदि कोई उपयोगकर्ता 2 नंबरों -1और 1(जैसे:) के साथ एक संदेश भेजता है '1,0', तो एक अल्पविराम के साथ अलग हो जाता है, यह वहाँ चला जाएगा। यह पूरी तरह से भरोसा है कि यह टीम के साथी हैं।

यह अब JSON पर संचार करता है। इसकी एक बहुत ही मूल संरचना है:

  • getMsg:
    • a: क्रिया का निर्धारण करता है:
      • 0: बंद करो
      • 1: चाल
    • m: भेजने के लिए आंदोलन
      • {x: n, y: n}: x और y के साथ वस्तु, -1 और 1 के बीच
      • कच्चे मान को ग्रिड में दर्शाए गए नंबर के साथ वापस करना है।
  • setMsg:
    • a: इंगित करता है कि क्या यह स्थानांतरित हुआ या यदि यह बंद हो गया;
    • ओ: मेरी पुरानी स्थिति के साथ एक सरणी;
    • एम: कोड द्वारा लौटाया गया कच्चा आंदोलन;
    • आईडी: यदि किसी आदेश का सम्मान किया गया था, तो इसके लिए दोषी की आईडी होगी;
    • ई: सभी दुश्मन पदों के साथ सूची। गैर-मुद्रण योग्य वर्णों से बचने के लिए प्रत्येक स्थिति 32 से पक्षपाती है। दुश्मन की स्थिति प्राप्त करने के लिए string.charCodeAt (i) -32 का उपयोग करें। यह लंबाई के साथ एक स्ट्रिंग होगी। प्रत्येक शत्रु 2 वर्ण का होगा।

इसे नियंत्रित करने के लिए एक संदेश का एक उदाहरण:

"14732":{"a":1,"m":3}

जो भेजेगा:

"a":1,"o":[x,y],"m":3,"id":id,"e":""

वह थोड़ा स्वार्थी भी है और आपकी मदद नहीं करेगा और अब वह एक स्थिर बीकन के रूप में सहायक है।

यदि यह संदेश गलत है (प्रारूप सही नहीं है), "}इसके बजाय जोड़ने का प्रयास करें }


यह 6-घंटे की सीमा के बाद संपादित किया गया था, और इसके बाद इसे 8 तक बढ़ा दिया गया था।

यह अब टूटा नहीं है और अंतिम संस्करण के रूप में रहेगा।


2
लाल टीम में किसी के रूप में, मुझे लगता है कि एक महत्वपूर्ण बात जो हमें शामिल करनी चाहिए, वह हमेशा आपके वर्तमान राज्य के साथ एक संदेश के रूप में और कुछ सहमत-किसी वस्तु के रूप में आसपास होती है ( इसमें शामिल होना चाहिए कि यह किस कदम पर सेट किया गया था, अन्यथा बॉट जीते गए ' t पता है कि कौन सा राज्य पुराना है)। यह अन्य, बाद में बॉट को अपने स्वयं के परिवेश, संभवतः पूरे बोर्ड से अधिक जागरूक होने और बेहतर निर्णय लेने की अनुमति देगा।
नाइट

@ मैं आपसे सहमत हूँ, और इसीलिए मैंने JSON का उपयोग संवाद करने के लिए किया। मेरे पास बदलाव करने के लिए 5 घंटे और 22 मी है। कोई और विचार?
इस्माइल मिगुएल

1
मैं सोच रहा हूं कि पहले कुछ स्कैनर होना चाहिए। हमें पूरे बोर्ड को उड़ाने के लिए केवल चार तरफ की ओर स्वीप करने की आवश्यकता है (32 प्रभावी स्कैनिंग चौड़ाई बोर्ड के 1/4 भाग को कवर करती है)। एक तरफ, एक बाइनरी या संपीड़ित स्ट्रिंग का उपयोग करके निकटतम एन बदमाशों को सेट करें, और या तो बुरे लोगों से बचें, या मारे जाने से बचने के लिए एक उचित रणनीति का उपयोग करके बुरे लोगों की तलाश करें और उन्हें अपने कोने पर न जाने दें, न ही ऊपर या नीचे। आप?)।
एडम डेविस

1
@IsmaelMiguel नोप। मैं जल्द से जल्द एक जमा करने की उम्मीद कर रहा हूं, लेकिन जावास्क्रिप्ट को नहीं जानना मुझे धीमा कर रहा है।
एडम डेविस

3
यदि यह टूटा नहीं है, तो अव्यवस्था को कम करने के लिए पुरानी अप्रचलित टिप्पणियों को हटा दें।
निति

10

रेड टीम - कायर

var bounds = 128;
var movements = [[0,0], [-1,-1],[1,-1],[-1,0],[1,0],[-1,1],[1,1]];

var distanceTo = function(x, y, pixel)
{
    var a = x - pixel.x;
    var b = y - pixel.y;
    return Math.sqrt( a*a + b*b );
}

var isDiagonallyAdjacent = function(x, y, pixel)
{
    return (Math.abs(pixel.x - x) == 1 && Math.abs(pixel.y - y) == 1);
}

var canAttackMe = function(x, y, pixel)
{
    if(x == pixel.x && Math.abs(pixel.y - y) == 1)
    {
        return true;
    }
    else
    {
        return isDiagonallyAdjacent(x, y, pixel);
    }
}

var canIAttack = function(x, y, pixel)
{
    if(y == pixel.y && Math.abs(pixel.x - x) == 1)
    {
        return true;
    }
    else
    {
        return isDiagonallyAdjacent(x, y, pixel);
    }
}

var isPositionSafe = function(x2, y2, enemies)
{
    var safe = true;
    for(var i in enemies)
    {
        if(canAttackMe(x2, y2, enemies[i]))
        {
            safe = false;
            break;
        }
    }
    return safe;
}

var moveTo = function(x, y, x2, y2)
{
    if(x2 < x)
    {
        if(y2 < y) return 4;
        else if(y2 > y) return 5;
        else return 2;
    }
    else if(x2 > x)
    {
        if(y2 < y) return 3;
        else if(y2 > y) return 6;
        else return 1;
    }
    else
    {
        if(y2 < y)
        {
            if(x2 < bounds)
            {
                return 3;
            }
            return 4;
        }
        else if(y2 > y)
        {
            if(x2 >= 0)
            {
                return 5;
            }
            return 6;
        }
    }
    return 0;
}

var getMovement = function(i)
{
    var m = [[0, 0], [1, 0], [-1, 0], [1, -1], [-1, -1], [-1, 1], [1, 1]];
    return m[i];
}

if(eNear.length == 0)
{
    // Move at random
    //return Math.floor((Math.random() * 6) + 1);
    return 0;
}
else 
{
    var safePositions = [];
    var isSafePosition = function(x2, y2)
    {
        for(var i in safePositions)
        {
            if(safePositions[i][0]==x2 && safePositions[i][0]==y2)
            {
                return true;
            }
        }
        return false;
    }

    for(var i in movements)
    {
        var x2 = x + movements[i][0];
        var y2 = y + movements[i][1];
        if(x2 >= 0 && x2 < bounds && y2 >= 0 && y2 < bounds
            && isPositionSafe(x2, y2, eNear))
        {
            safePositions.push([x + movements[i][0], y + movements[i][1]]);
        }
    }

    var dangerousPixels = [];
    var attackablePixels = [];
    var kamikazePixels = [];

    for(var ei in eNear)
    {
        var e = eNear[ei];
        var attackable = canIAttack(x, y, e);
        var dangerous = canAttackMe(x, y, e);
        if( attackable )
        {
            if(isSafePosition(e.x, e.y))
            {
                attackablePixels.push(e);
            }
            else
            {
                kamikazePixels.push(e);
            }
        }
        else if(dangerous)
        {
            dangerousPixels.push(e);
        }
    }
    if(attackablePixels.length == eNear.length)
    {
        return moveTo(attackablePixels[0].x, attackablePixels[0].y);
    }
    if(attackablePixels.length > 0 && tNear.length >= eNear.length)
    {
        // Attack only if we have greater numbers
        // Attack one of them at random
        var i = Math.floor(Math.random() * attackablePixels.length);
        return moveTo(x, y, attackablePixels[i].x, attackablePixels[i].y);
    }
    else if(dangerousPixels.length > 0 && safePositions.length > 0)
    {
        // Flee
        var i = Math.floor(Math.random() * safePositions.length);
        return moveTo(x, y, safePositions[i][0], safePositions[i][1]);

    }
    else if(dangerousPixels.length > 0 && safePositions.length == 0 && kamikazePixels.length > 0)
    {
        var i = Math.floor(Math.random() * kamikazePixels.length);
        return moveTo(x, y, kamikazePixels[i].x, kamikazePixels[i].y);
    }
    else 
    {
        var nearest = null;
        var nearestDist = Infinity;
        for(var ei in eNear)
        {
            var e = eNear[ei];
            var d = distanceTo(x, y, e);
            if(nearest === null || d < nearestDist)
            {
                nearestDist = d;
                nearest = e;
            }
        }

        if(tNear.length >= eNear.length)
        {
            // Attack the nearest
            return moveTo(x, y, nearest.x, nearest.y);
        }
        else
        {
            // Get Away from the nearest
            var n = moveTo(x, y, nearest.x, nearest.y);
            var m = getMovement(n);
            var x2 = x-m[0];
            var y2 = y-m[1];
            if(x2 < 0 || x2 >= bounds) x2 = x + m[0];
            if(y2 < 0 || y2 >= bounds) y2 = y + m[1];
            return moveTo(x, y, x2, y2);
        }
    }
}

यह बॉट जितना संभव हो उतना पता लगाने से बचता है। जब एक या अधिक शत्रु दृष्टि में होते हैं, तो कई चीजें हो सकती हैं:

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

किसी के साथ संवाद नहीं करता है, अगर कोई उसे सुन सकता है और उसके बाद जा सकता है।

यह टीम के लिए सबसे उपयोगी बॉट नहीं हो सकता है, लेकिन उसे हर किसी से दूर जाने की कोशिश करते हुए देखना मजेदार था।


ठीक है, मुझे आपके बॉट से प्यार है। मेरा इसके विपरीत है (यह दुश्मनों को ढूंढता है और फिर केंद्र की ओर भागता है), इसलिए उनकी एक शानदार बातचीत होती है, जहां मेरा आपको कोने से बाहर तंग करने और बीच में खींचने की कोशिश हो सकती है, लेकिन तब अगर आप देखते हैं कि यह किसी को डर लगता है और कोने में वापस चला जाता है, जबकि मेरा पीछा करता है।
Hylianpuffball

धन्यवाद! मुझे यह देखकर अजीब लगता है कि वह दूसरों के साथ बातचीत करता है। लेकिन मुझे सीमाओं के बारे में कुछ कीड़े मिले और यह कैसे उछलता है, लेकिन उन्हें ठीक करने के लिए बहुत देर हो चुकी है ... इसलिए यह उतना अच्छा नहीं है जितना कि मैं चाहता हूं।
रोरलर्क

9

ब्लू टीम - ईगल

var move_valid = function(x, y, move){
    var move_x = {0:0, 1:0, 2:0, 3:1, 4:-1, 5:-1, 6:1};
    var move_y = {0:0, 1:1, 2:-1, 3:-1, 4:-1, 5:1, 6:1};
    var xx = x + move_x[move];
    var yy = y + move_y[move];
    return (1 <= xx && xx <= 125 && 1 <= yy && yy <= 125);
}
var sign = function(x){
    if (x === 0) return 0;
    else if (x > 0) return 1;
    else return -1;
}

if (eNear.length === 0) {
    if (getMsg(29577).length > 0) {
        var last_move = parseInt(getMsg(29577).charAt(0))
        if (last_move !== 0 && 
            move_valid(x, y, last_move) &&
            Math.random() > 0.03) return last_move;
    }

    var moves = [1, 2, 3, 4, 5, 6];
    var valid_moves = [];
    for (var move of moves){if (move_valid(x, y, move)) valid_moves.push(move);}
    if (valid_moves.length === 0) valid_moves.push(0);
    var move = moves[Math.floor(Math.random()*moves.length)];
    setMsg(move.toString());
    return move;
} else {
    var enemy = eNear[0];
    var dist = Math.max(Math.abs(x- enemy.x), Math.abs(y - enemy.y))
    var dir_x = sign(enemy.x - x);
    var dir_y = sign(enemy.y - y);
    var dir_to_move = {1: {1: 6, 0: -1, "-1": 3}, 0: {1: 1, 0: 1, "-1": 2}, "-1": {1: 5, 0: -1, "-1": 4}};
    var move = dir_to_move[dir_x][dir_y];
    var fight_count = 0;
    if (getMsg(29577).length > 1) {
        fight_count = parseInt(getMsg(29577).substring(1));
    }
    fight_count += 1;
    if (fight_count > 100){
        if (fight_count > 110) fight_count = 0;
        move = dir_to_move[-dir_x][dir_x !== 0 ? -dir_y : (Math.random() > 0.5 ? 1 : -1)];
        setMsg(move.toString() + fight_count.toString());
        return move;
    } else {
        if (dist > 2) {
            // Move towards enemy
            if (move === -1) move = dir_to_move[dir_x][Math.random() > 0.5 ? 1 : -1]
            setMsg(move.toString() + fight_count.toString());
            return move;
        } else if (dist === 2) {
            if (Math.abs(x - enemy.x) < 2) {
                // go one down if === 0
                // go diagonal, if ===1
                // move is already correct  
            } else if (Math.abs(y - enemy.y) === 2) {
                // dist_x == dist_y
                move = dir_to_move[0][dir_y];
            } else if (Math.abs(y - enemy.y) === 1) {
                move = dir_to_move[dir_x][-dir_y];
            } else {
                // dist_y == 0, dist_x == 2
                move = dir_to_move[0][Math.random() > 0.5 ? 1 : -1]
            }
            setMsg(move.toString() + fight_count.toString());
            return move;
        } else if (dist === 1) {
            if (move !== -1) {
                // Kill
                setMsg(move.toString() + fight_count.toString());
                return move;
            } else {
                // Run away
                var move = dir_to_move[-dir_x][Math.random() > 0.5 ? 1 : -1]
                setMsg(move.toString() + fight_count.toString());
                return move;
            }
        }
    }
    return 0;
}

मैं इस समय अपने बॉट के साथ काफी खुश हूं। इसकी निम्नलिखित रणनीति है:

  • यदि कोई शत्रु आसपास नहीं है, तो एक यादृच्छिक दिशा में आगे बढ़ें। यदि मैं दीवार से टकराता हूं या लगभग 33 चालों के बाद, मैं दिशा बदल देता हूं।
  • अगर मुझे कोई दुश्मन दिखाई देता है, तो मैं उसकी ओर बढ़ता हूं। (ध्यान से एक क्षेत्र में नहीं जाने के लिए, जहां दुश्मन मुझे मार सकता है)। एक बार जब मैं काफी पास हो गया, तो ऊपर या नीचे से उसकी ओर बढ़ा और मार डाला।

7

ब्लू टीम - दुश्मन

for (var i = 0; i < eNear.length; i++) {
    var enemy = eNear[i];
    var rx = enemy.x - x;
    var ry = enemy.y - y;
    if (rx == -1) {
        if (ry == 1) {
            return 4;
        }
        return 5;
    }
    if (rx == 0) {
        if (ry == 1) {
            return 2;
        }
        return 1;
    }
    if (rx == 1) {
        if (ry == 1) {
            return 3;
        }
        return 6;
    }
}
return Math.floor(Math.random() * 7);

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


क्षमा करें, पिछली बार मैंने जावास्क्रिप्ट को 2 साल पहले की तरह कोडित किया था।
लवजो

2
Math.floor, नहीं Math.float!
जकूबे

1
@Jakube या (Math.random() * 6) & 6या (Math.random() * 6) << 0या (Math.random() * 6) >> 0 (codegolf के लिए उपयोगी)।
इस्माइल मिगुएल

क्या आपको करने की आवश्यकता नहीं है Math.random() * 7? मैंने कुछ टेस्ट रन की कोशिश की है, और ऐसा लगता है कि आपका बॉट नीचे दाईं ओर नहीं जाता है। IIRC Math.random()समावेशी 0 और अनन्य 1 है जिसका मतलब है कि * 6वास्तव में कभी नहीं 6.
डेस्ट्रिक्टर

1
क्षमा करें सब लोग, मैं जावास्क्रिप्ट पर चूसना।
लवजो

7

रेड टीम - जिटरी रेड चार्जर

var direction = 3;
if (getMsg(14314) === ''){
    setMsg('3');
}
if (getMsg(14314) === '3'){
    direction = 6;
    setMsg('6');
}
else if (getMsg(14314) === '4'){
    direction = 5;
    setMsg('5');
}
else if (getMsg(14314) === '5'){
    direction = 4;
    setMsg('4');
}
else if (getMsg(14314) === '6'){
    direction = 3;
    setMsg('3');
}
if(x === 0){
    setMsg('3');
}
else if(x === 127){
    setMsg('5');
}
return direction;

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

संपादित करें: रेड चार्जर ने एनर्जी ड्रिंक के एक गैलन को नीचे गिरा दिया और अब घबराना बंद नहीं कर सकता, यह अपने लाभ के लिए भी इसका उपयोग करने की उम्मीद कर रहा है। यह अपने साथियों को सुनने के लिए बहुत कैफीनयुक्त है, लेकिन यह हर एक चाल को चिल्ला रहा है।


6

ब्लू टीम - LazySoldier

try {
    var state = getMsg(38671);
    if(state == null) {
       state = {direction:x==0?1:-1};
    } else {
       state = JSON.parse(state);
    }

    var choice = 0;    

    var escape=function(dx,dy) {
    if(dx==-1) {
       return y>0?4:5;
    } else if (dx==1) {
       return y>0?3:6;
    } else return 0;
    };

    var eat=function(dx,dy) {
       var b={'-1,-1':4, '0,-1':2,'1,-1':3,'-1,1':5,'0,1':1,'1,1':6};
       k=dx+','+dy;
       if(b[k]) {
       return b[k];
       } else return 0;
    };

    for(var i=0;i<eNear.length;i++) {
        var enemy = eNear[i];
        var dx=enemy.x-x;
        var dy=enemy.y-y;
        if(dy==0 && (dx==-1||dx==1)) {
            choice = escape(dx,dy);
            break;
        } else if(dy==-1 || dy==1) {
            choice = eat(dx,dy);
            break;
        }
    }

    if(x==0 || x==127) {
        state.direction=-state.direction;
    }

    if(choice == 0) {
       choice=state.direction==-1?2:1;
    }

    setMsg(JSON.stringify(state));
    return choice;

} catch(e) {
    if(console && console.error) {
        console.error(e);
    }
    return 0;
}

JSON संदेश आम तौर पर कितने बाइट्स है, क्या आप जानते हैं? संदेश के केवल पहले 64 अक्षरों को संग्रहीत किया जा सकता है।
PhiNotPi

.. मैं उस सीमा के बारे में भूल गया :(
आहारकर्ता

मुझे लगता है कि यह विरोधियों की मात्रा पर निर्भर करेगा, क्योंकि json string में समीपवर्ती प्रमेयों के पद शामिल हैं
Dieter

मैं अभी प्रारूप बदल रहा हूँ
डायटर

1
आपको JSON.parseएक कोशिश / कैच ब्लॉक या कुछ और करने की ज़रूरत है ... यह बहुत अधिक त्रुटियों का कारण बन रहा है।
12Me21

6

ब्लू टीम - मास किलर

var i, j, enemies = [];
var DIRECTIONS = [4, 2, 3, 5, 1, 6];

// initialize 5x5 surroundings
for (i = 0; i < 5; i++) { 
    enemies[i] = [];
    for (j = 0; j < 5; j++) {
        enemies[i][j] = 0;
    }
}

// get amounts of enemies there
for (i = 0; i < eNear.length; i++) {
    var xOff = eNear[i].x - x + 2;
    var yOff = eNear[i].y - y + 2;
    if (xOff >= 0 && xOff <= 4 && yOff >= 0 && yOff <= 4) {
        enemies[yOff][xOff]++;
    }
}

// get maximum amount of direct neighbours, where I can move
var max = 0, index = -1;
// check the triple above
for (i = 0; i < 3; i++) { 
    if (enemies[1][i+1] > max) {
        max = enemies[1][i+1];
        index = i;
    }
}
// check the triple below
for (i = 0; i < 3; i++) { 
    if (enemies[3][i+1] > max) {
        max = enemies[3][i+1];
        index = i + 3;
    }
}

// if there is any reachable enemy, stomp on where the biggest amount of them is 
if (max > 0) {
    return DIRECTIONS[index];
}

// otherwise, if enemy is near (though unreachable), try to move that I am above or below him
var unreachable = [];
unreachable[4] = enemies[0][1] + enemies[2][1]; // NW (north west)
unreachable[3] = enemies[0][3] + enemies[2][3]; // NE
unreachable[5] = enemies[4][1] + enemies[2][1]; // SW
unreachable[6] = enemies[4][3] + enemies[2][3]; // SE
unreachable[2] = enemies[0][2];                 // N
unreachable[1] = enemies[4][2];                 // S

max = 0, index = 0;
for (i = 1; i <= 6; i++) {
    if (unreachable[i] > max) {
        max = unreachable[i];
        index = i;
    }
}

if (max > 0) {
    return index;
}

// if no one is near, let's move randomly
return Math.round(Math.random() * 6);

मुझे लगता है कि बहुत सरल रणनीति है। मैं अपने द्वारा सीधे पहुंच सकने वाले दुश्मनों की गिनती करता हूं (मुझे लगता है कि उनमें से टन होंगे :)) और सबसे बड़ी राशि को मार देंगे। अगर कोई नहीं है, तो कम से कम मैं दुश्मनों की सबसे बड़ी राशि से ऊपर या नीचे कदम रखकर खुद को ढालने की कोशिश करूंगा ताकि अगले कदम पर उन्हें मारने की उम्मीद हो।

मैंने दीवारों को ध्यान में रखा, इसलिए मैंने उन्हें अनदेखा कर दिया। वैसे भी यह काफी लंबा है।

मैं इस कोड का परीक्षण / चलाने में असमर्थ था, इसलिए कई बग होंगे।


5

ब्लू टीम - वॉचडॉग

var me = 38403;
var currentOwner = parseInt(getMsg(me));
var deltas = {1:{x:0,y:1},2:{x:0,y:-1},3:{x:1,y:-1},4:{x:-1,y:-1},5:{x:-1,y:1},6:{x:1,y:1}};
var check_danger = function(ennemi){
    for(var i in deltas){
        if(Math.abs(ennemi.x-x-deltas[i].x)<3 && Math.abs(ennemi.y-y-deltas[i].y)<2){
            delete deltas[i];
        }
    }
}
if(eNear.length > 0){
    for(var i in eNear){
        check_danger(eNear[i]);
    }
}
for(var i in deltas){
    if(x+deltas[i].x>126 || x+deltas[i].x<1 || y+deltas[i].y>126 || y+deltas[i].y<1)
        delete deltas[i];
}
if(!isNaN(currentOwner) && getMsg(currentOwner)!='X'){
    var Owner;
    if(tNear.length > 0){
        for(var i in tNear){
            if(tNear[i].id == currentOwner)
                Owner=tNear[i];
        }
    }
    if(Owner){
        var min=32;
        var choosen;
        var keys = Object.keys(deltas);
        if(keys.length>0){
            for(var i in deltas){
                var value = Math.abs(Owner.x-x-deltas[i].x)+Math.abs(Owner.y-y-deltas[i].y);
                if(value<min){
                    min=value;
                    choosen=i;
                }
            }
            if(min>0)
                return parseInt(choosen);
        }
    }
}
if(tNear.length > 0){
    setMsg(""+tNear[0].id);
}
var keys = Object.keys(deltas);
if(keys.length>0){
    if(eNear.length>0){
        var max=0;
        var choosen;
        for(var i in deltas){
            var value = Math.abs(eNear[0].x-x-deltas[i].x)+Math.abs(eNear[0].y-y-deltas[i].y);
            if(value>max){
                max=value;
                choosen=i;
            }
        }
        if(max>5)
            return parseInt(choosen);
    }
}
var deltas = {1:{x:0,y:1},2:{x:0,y:-1},3:{x:1,y:-1},4:{x:-1,y:-1},5:{x:-1,y:1},6:{x:1,y:1}};
if(eNear.length>0){
    var min=32;
    var choosen;
    for(var i in deltas){
        var value = Math.abs(eNear[0].x-x-deltas[i].x)+Math.abs(eNear[0].y-y-deltas[i].y);
        if(value<min){
            min=value;
            choosen=i;
        }
    }
    if(min==0)
        return parseInt(choosen);
}
return parseInt(keys[Math.floor(keys.length*Math.random())]);

यह तब तक बेतरतीब ढंग से आगे बढ़ता है जब तक कि यह एक सहयोगी को पकड़ न ले, यदि ऐसा है तो यह उसका पीछा करता है। यह मारने से बचने की कोशिश करता है, और मार सकता है अगर वह कर सकता है। भयानक कोड के लिए क्षमा करें, मैं सीधे चला गया और रिफैक्टिंग के बारे में भूल गया। अगर मेरे पास समय है तो मैं पठनीयता को पुनः प्राप्त करने की कोशिश करूँगा :)


5

रेड टीम - सीकर कमांडर

var myself = 29354;

//Adjust eNear to account for any friendly information, using Lazy Slayer format

//Automatically add Lazy Slayer to list, even if out of range
var mytNear = [{
    id: 14732
}].concat(tNear);

var myeNear = [].concat(eNear);
var commandable = [];
var orders = [];

for (var i = 0; i < mytNear.length; i++) {
    try {
        var msg = getMsg(mytNear[i].id);
        var enemies = undefined;
        if (msg.indexOf('"m":') !== -1) {
            commandable.push(mytNear[i]);
        }
        if (msg.indexOf(myself) !== -1) {
            var j = msg.indexOf(myself)+(myself+' ').length;
            for (; j < msg.length; j++) {
                var order = parseInt(msg.substr(j,1));
                if (order) {
                    orders.push(order);
                    break;
                }
            }
        }
        if (msg.indexOf('"e":') !== -1) {
            var enemies = msg.substr(msg.indexOf('"e":')+5).split('"')[0];
            if(!enemies) continue;
            if(enemies.charCodeAt(j) > (32+127)) {
                for (var j = 0; j < enemies.length-1; j+=2) {
                    myeNear.push({
                        x: enemies.charCodeAt(j)-174,
                        y: enemies.charCodeAt(j+1)-174,
                    });
                }
            } else {
                for (var j = 0; j < enemies.length-1; j+=2) {
                    myeNear.push({
                        x: enemies.charCodeAt(j)-32,
                        y: enemies.charCodeAt(j+1)-32,
                    });
                }
            }
        }
    } catch (e) {}
}

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

var iAmInDanger = function(meX, meY, himX, himY) {
    return (Math.abs(meY - himY) === 1 && Math.abs(meX - himX) <= 1);
};

var iCanKillHim = function(meX, meY, himX, himY) {
    return (Math.abs(meX - himX) === 1 && Math.abs(meY - himY) <= 1);
};

var getMove = function(x, y, tNear, eNear, messages) {
    var minimalDistanceToFriend = 2;
    var chosenMove = null;
    var newDistanceToFriend = null;
    var minimalVerticalDistanceToEnemy = null,
        minimalHorizontalDistanceToEnemy = null;
    var closestFriend = null;
    var closestEnemy = null;
    var possibleVictims = [];
    var possibleMoves = [{
        newX: x,
        newY: y
    }, {
        newX: x + 1,
        newY: y
    }, {
        newX: x - 1,
        newY: y
    }, {
        newX: x + 1,
        newY: y - 1
    }, {
        newX: x - 1,
        newY: y - 1
    }, {
        newX: x - 1,
        newY: y + 1
    }, {
        newX: x + 1,
        newY: y + 1
    }];

    for (i = 0; i < possibleMoves.length; i++) {
        if (possibleMoves[i].newX < 0 || possibleMoves[i].newY < 0 || possibleMoves[i].newX > 127 || possibleMoves[i].newY > 127) {
            possibleMoves[i] = null;
        }
    }

    for (var i = 0; i < eNear.length; i++) {
        if (closestEnemy === null || calculateDistance(x, y, closestEnemy.x, closestEnemy.y) > calculateDistance(x, y, eNear[i].x, eNear[i].y)) {
            closestEnemy = eNear[i];
        }
        if (Math.abs(x - eNear[i].x) <= 2 && Math.abs(y - eNear[i].y) <= 2) {
            possibleVictims.push(eNear[i]);
        }
    }

    for (i = 0; i < tNear.length; i++) {
        if (closestFriend === null || calculateDistance(x, y, closestFriend.x, closestFriend.y) > calculateDistance(x, y, tNear[i].x, tNear[i].y)) {
            closestFriend = tNear[i];
        }
    }

    //If moving to the spot would put me in danger, don't do it
    for (i = 0; i < possibleMoves.length; i++) {
        for (var j = 0; j < possibleVictims.length; j++) {
            if (possibleMoves[i] !== null && iAmInDanger(possibleMoves[i].newX, possibleMoves[i].newY, possibleVictims[j].x, possibleVictims[j].y)) {
                possibleMoves[i] = null;
            }
        }
    }

    //If moving to the spot kills an enemy, do it now
    for (i = 0; i < possibleMoves.length; i++) {
        for (j = 0; j < possibleVictims.length; j++) {
            if (possibleMoves[i] !== null && possibleMoves[i].newX === possibleVictims[j].x && possibleMoves[i].newY === possibleVictims[j].y) {
                messages[2] = 0;
                return i;
            }
        }
    }

    //Enemy in sight
    if (possibleVictims.length > 0) {
        //This can only occur when they are in my blind spot
        if (iAmInDanger(x, y, possibleVictims[0].x, possibleVictims[0].y)) {
            if (closestFriend !== null) {
                for (i = 0; i < possibleMoves.length; i++) {
                    if (possibleMoves[i] !== null) {
                        var distance = calculateDistance(possibleMoves[i].newX, possibleMoves[i].newY, closestFriend.x, closestFriend.y);
                        if (newDistanceToFriend === null || (distance < newDistanceToFriend && distance >= minimalDistanceToFriend)) {
                            newDistanceToFriend = distance;
                            chosenMove = i;
                        }
                    }
                }
                messages[2] = 0;
                setMessage();
                return chosenMove;
            } else {
                var aggressiveMoves = [];
                var randomMoves = [];

                for (i = 0; i < possibleMoves.length; i++) {
                    if (possibleMoves[i] !== null) {
                        if (iCanKillHim(possibleMoves[i].newX, possibleMoves[i].newY, possibleVictims[0].x, possibleVictims[0].y)) {
                            aggressiveMoves.push(i);
                        }
                        randomMoves.push(i);
                    }
                }
                var approachCount = messages[2] || 0;
                if (approachCount < 5 && aggressiveMoves.length > 0) {
                    messages[2] = approachCount + 1;
                    chosenMove = aggressiveMoves[Math.floor(Math.random() * aggressiveMoves.length)];
                    return chosenMove;
                } else {
                    chosenMove = randomMoves[Math.floor(Math.random() * randomMoves.length)];
                    return chosenMove;
                }
            }
        }

    }

    //Move towards closest enemy
    if (closestEnemy != null) {
        for (i = 1; i < possibleMoves.length; i++) {
            if (possibleMoves[i] !== null) {
                var verticalDistance = Math.abs(possibleMoves[i].newY - closestEnemy.y);
                var horizontalDistance = Math.abs(possibleMoves[i].newX - closestEnemy.x);
                if (minimalVerticalDistanceToEnemy === null || verticalDistance <= minimalVerticalDistanceToEnemy) {
                    if (minimalVerticalDistanceToEnemy !== null && verticalDistance === minimalVerticalDistanceToEnemy) {
                        if (minimalHorizontalDistanceToEnemy === null || horizontalDistance <= minimalHorizontalDistanceToEnemy) {
                            minimalHorizontalDistanceToEnemy = horizontalDistance;
                            chosenMove = i;
                        }
                    } else {
                        minimalVerticalDistanceToEnemy = verticalDistance;
                        minimalHorizontalDistanceToEnemy = horizontalDistance;
                        chosenMove = i;
                    }
                }
            }
        }
        messages[2] = 0;
        return chosenMove;
    }

    //Take the order
    for (var i = 0; i < orders.length; i++) {
        var order = orders[i].m || orders[i];
        if (possibleMoves[order]) {
            return orders;
        }
    }

    var seekStatus = messages[3] || 0;
    var seekCount = messages[4] || 0;
    seekStatus = parseInt(seekStatus, 10);
    seekCount = parseInt(seekCount, 10);

    switch (seekStatus) {
        case 0:
            if (x < 16) {
                seekCount = 0;
                if (y > 111) {
                    seekStatus = 4;
                } else {
                    seekStatus = 1;
                }
            } else {
                chosenMove = 2;
            }
            break;
        case 1:
            seekCount++;
            if (y > 111 || seekCount > 31) {
                seekStatus = 2;
            } else {
                if (seekCount % 2 === 0) {
                    chosenMove = 5;
                } else {
                    chosenMove = 6;
                }
            }
            break;
        case 2:
            if (x > 111) {
                seekCount = 0;
                if (y > 111) {
                    seekStatus = 4;
                } else {
                    seekStatus = 3;
                }
            } else {
                chosenMove = 1;
            }
            break;
        case 3:
            seekCount++;
            if (y > 111 || seekCount > 31) {
                seekStatus = 0;
            } else {
                if (seekCount % 2 === 0) {
                    chosenMove = 5;
                } else {
                    chosenMove = 6;
                }
            }
            break;
        case 4:
            seekCount++;
            if (y < 16) {
                if (x > 63) {
                    seekStatus = 0;
                } else {
                    seekStatus = 2;
                }
            } else {
                if (seekCount % 2 === 0) {
                    chosenMove = 3;
                } else {
                    chosenMove = 4;
                }
            }
            break;
    }

    messages[2] = 0;
    messages[3] = seekStatus;
    messages[4] = seekCount;
    return chosenMove;
}

var messageObj = JSON.parse('{'+getMsg(myself)+'}');
if (!messageObj.$) {
    messageObj = {$:0};
}
var approachCount = (messageObj.$ & 7);
var seekStatus = ((messageObj.$ >> 3) & 7);
var seekCount = ((messageObj.$ >> 6));
var messages = [x, y, approachCount, seekStatus, seekCount];
var myMove = getMove(x, y, mytNear, myeNear, messages);
var msg = '"$":'+(messages[2] + (messages[3]<<3) + (messages[4]<<6)+',"m":'+myMove);
orders.length = 0;

//Issue commands to my allies
for (var i = 0; i < commandable.length; i++) {
    var ally = commandable[i];
    var command = getMove(ally.x, ally.y, tNear, myeNear, messages);
    var cmdStr = ',"'+ally.id+'":{"m":"'+command+'","a":1,"id":'+myself+'}'
    if (msg.length + cmdStr.length < 64) {
        msg += cmdStr;
    }
}

if (msg.length+9 < 64) {
    //Add my list of enemies
    var enemies = "";
    for(var i = 0; i < myeNear; i++) {
        if (msg.length+enemies.length+9 > 64) {
            break;
        }
        enemies+=String.fromCharCode(eNear[i].x+174)+String.fromCharCode(eNear[i].y+174);
    }
    msg += ',"e":"'+enemies+'"';
}

setMsg(msg);
return myMove;

यह कुछ संशोधनों के साथ मिनोस के सीकरबोट की एक प्रति है।

  • बेहतर संदेश वितरण के लिए संपीड़ित आंतरिक मेमोरी "$":[seekmode]

  • आलसी कातिलों के JSON प्रारूप का उपयोग करते हुए सहयोगी से दुश्मन की स्थिति को पढ़ता है "e":"[positions]"; [positions]दोनों से ऑफसेट स्वीकार करता है 32और174

  • Lazy Slayer के JSON फॉर्मेट में, "e":"[positions]"ऑफसेट द्वारा दुश्मन की स्थिति की रिपोर्ट करता है174

  • रिपोर्ट्स "m":[move]यह बताती हैं कि इस बॉट को कमांड किया जा सकता है

  • मुद्दों का उपयोग कर अन्य बॉट को आदेश देता है "[ally_id]":{"m":[move],"a":1,"id":29354}। सहयोगी सहयोगी के स्थान को छोड़कर एक ही साधक एल्गोरिथ्म का उपयोग करता है। यदि अन्य बॉट इन आदेशों को सुनते हैं, तो उन्हें एक साथ समूह बनाना चाहिए और एक पैकेट में शिकार करना चाहिए। यदि सहयोगी के संदेश में केवल आदेश दिए गए हैं"m":

  • अन्य बॉट्स से आज्ञाओं का पालन करता है, जैसे: "29354":[move]या "29354":{"m":[move]। कमांड का पालन केवल तब किया जाता है जब कोई दुश्मन सीमा में न हो और कोई अन्य सहयोगी दुश्मन की सूचना न दे रहा हो


मैं 32 के बजाय 174 तक निर्देशांक बढ़ाने की सिफारिश करूंगा। कुछ संदेश जो आलसी कातिलों को भेज रहे थे, जैसे थे ""a":0,"o":[122,70],"m":0,"e":"f"":। आप हमसे चैट में शामिल हो सकते हैं यदि आप भी चाहते हैं।
TheNumberOne

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

5

रेड टीम - बाउंसरबोट

function getDir(diff){
  return (diff < 0) ? -1 : ((diff > 0) ? 1 : 0);
}
function randInt(max){
  return Math.ceil(Math.random() * max);
}
var me = 29750;
var moves = [
  [4,3,3],
  [2,0,1],
  [5,5,6]
]; // Directions: -1 = up/left, 1 = down/right, 0 = none
if(x === 0){
  moves[0] = [3,3,3];
  moves[2] = [6,6,6];
} else if(x == 127){
  moves[0] = [4,4,4];
  moves[2] = [5,5,5];
}
for(var i in eNear){
  var xDiff = eNear[i].x - x,
      yDiff = eNear[i].y - y;
  if(xDiff >= -1 && xDiff <= 1 && yDiff >= -1 && yDiff <= 1){
    // If the enemy is directly adjacent, attack
    setMsg('');
    return moves[yDiff + 1][xDiff + 1];
  }
}
if(eNear.length > 0){
  var xDiff = eNear[0].x - x,
      yDiff = eNear[0].y - y;
  // If it can't attack, move toward the enemy.
  if(Math.abs(yDiff) == 2){
    if(xDiff >= -2 && xDiff <= 0) return 1;
    else if(xDiff == 2 || xDiff === 1) return 2;
  }
  return moves[getDir(yDiff) + 1][getDir(xDiff) + 1];
}
var msg = getMsg(me) || '',
    newDir = parseInt(msg);
if(msg === ''){
  newDir = randInt(4) + 2;
}
var isEndgame = move > 512;
     if(x === 0 || (isEndgame && x < 11)) newDir = (msg == 4) ? 3 : 6;
else if(x == 127 || (isEndgame && x > 116)) newDir = (msg == 3) ? 4 : 5;
else if((!isEndgame && y < 11) || y === 0) newDir = (msg == 4) ? 5 : 6;
else if((!isEndgame && y > 116) || y == 127) newDir = (msg == 5) ? 4 : 3;
if(newDir != msg) setMsg(newDir.toString());
return newDir;

मेरा बॉट दीवार से दीवार की ओर उछलता है (बिल्कुल नहीं, इसलिए यह अलग-अलग जमीन को कवर करता है) दुश्मनों की तलाश में है। यदि यह अपनी सीमा में एक हो जाता है, तो यह हमला करता है, उन्हें एक दीवार की ओर ले जाता है, और उन्हें बाहर निकालने की कोशिश करता है (क्लब में बाउंसर लगता है)।


5

रेड टीम - साइडकिक

var possibleMoves = [
      {newX: x, newY: y, value: 1},
      {newX: x, newY: y + 1, value: 1},
      {newX: x, newY: y - 1, value: 1},
      {newX: x + 1, newY: y - 1, value: 1},
      {newX: x - 1, newY: y - 1, value: 1},
      {newX: x - 1, newY: y + 1, value: 1},
      {newX: x + 1, newY: y + 1, value: 1}
];

var isDeadly = function(myX, myY, eX, eY) {
      return (Math.abs(myY - eY) === 1 && Math.abs(myX - eX) <= 1);
}

//stay near helpful friends!
if (tNear.length > 0) {
      for (var i = 0; i < tNear.length; i++) {
      if (Math.abs(tNear[i].x - x) > 2) {
            if (tNear[i].x > x) {
                  possibleMoves[3].value = possibleMoves[3].value + 5;
                  possibleMoves[1].value = possibleMoves[1].value + 5;
                  possibleMoves[6].value = possibleMoves[6].value + 5;
            } else {
                  possibleMoves[4].value = possibleMoves[4].value + 5;
                  possibleMoves[2].value = possibleMoves[2].value + 5;
                  possibleMoves[5].value = possibleMoves[5].value + 5;
            }
      }
      if (Math.abs(tNear[i].y - y) > 2) {
            if (tNear[i].y > y) {
                  possibleMoves[5].value = possibleMoves[5].value + 5;
                  possibleMoves[6].value = possibleMoves[6].value + 5;
            } else {
                  possibleMoves[4].value = possibleMoves[4].value + 5;
                  possibleMoves[3].value = possibleMoves[3].value + 5;
            }
      }
      }
}
//chase those enemies!
if (eNear.length > 0) {
      for (var i = 0; i < eNear.length; i++) {
      if (Math.abs(eNear[i].x - x) > 2) {
            if (eNear[i].x > x) {
                  possibleMoves[3].value = possibleMoves[3].value + 5;
                  possibleMoves[1].value = possibleMoves[1].value + 5;
                  possibleMoves[6].value = possibleMoves[6].value + 5;
            } else {
                  possibleMoves[4].value = possibleMoves[4].value + 5;
                  possibleMoves[2].value = possibleMoves[2].value + 5;
                  possibleMoves[5].value = possibleMoves[5].value + 5;
            }
      }
      if (Math.abs(eNear[i].y - y) > 2) {
            if (eNear[i].y > y) {
                  possibleMoves[5].value = possibleMoves[5].value + 5;
                  possibleMoves[6].value = possibleMoves[6].value + 5;
            } else {
                  possibleMoves[4].value = possibleMoves[4].value + 5;
                  possibleMoves[3].value = possibleMoves[3].value + 5;
            }
      }
      }
}

//walls
if (x === 127){
       possibleMoves[3] = null;
       possibleMoves[1] = null;
       possibleMoves[6] = null;
}
if (x === 0){
       possibleMoves[4] = null;
       possibleMoves[2] = null;
       possibleMoves[5] = null;
}
if (y === 0){
       possibleMoves[3] = null;
       possibleMoves[4] = null;
}
if (y === 127){
       possibleMoves[5] = null;
       possibleMoves[6] = null;
}

//deadly enemies
for (var i = 0; i < eNear.length; i++) {
      for (var j = 0; j < possibleMoves.length; j++) {
            if (possibleMoves[j] !== null && isDeadly(possibleMoves[j].newX, possibleMoves[j].newY, eNear[i].x, eNear[i].y)) {
                  possibleMoves[j] = null;
            }
      }
}

var bestMoves = [];
for (var i = 0; i < possibleMoves.length; i++)
{
      if (possibleMoves[i] !== null) {
            if (bestMoves.length === 0 || possibleMoves[i].value > possibleMoves[bestMoves[0]].value) {
                  bestMoves = [i];
            }
            else if (possibleMoves[i].value === possibleMoves[bestMoves[0]].value) {
                  bestMoves.push(i);
            }
      }
}
var returnValue = bestMoves[Math.floor(Math.random()*(bestMoves.length))];

return returnValue;

चारों ओर टीम के साथी का पालन करना पसंद करते हैं, अच्छी बात यह है कि उनमें से बहुत कुछ है!


ध्यान दें, जब यह टीम वासु के बॉट के साथ जुड़ती है, तो यह कभी-कभी नीली जोड़ी को हरा सकती है।
लीख

1
@ मैं इसे देखा नहीं है; लेकिन मेरा अनुमान है कि मेरा वासु को मारने के लिए व्याकुलता है? काश मैं इसे अभी जोड़ सकता; मैं आगे कई मोड़ की भविष्यवाणी करने की कोशिश करता हूं और देखता हूं कि किस तरह की आत्महत्या - रणनीति जोड़ी के खिलाफ काम कर सकती है।
डबलडबल

5

ब्लू टीम - अनिर्णायक चुंबक

var Mul = 4;
var Mu = 2;
var Mur = 3;
var Mdl = 5;
var Md = 1;
var Mdr = 6;
var Ms = 0;
var M = [Ms,Md,Mu,Mur,Mul,Mdl,Mdr];
var C =  [Mul,Mur,Mdl,Mdr];
var Mc = [{x:0,y:0},{x:0,y:1},{x:0,y:-1},{x:1,y:-1},{x:-1,y:-1},{x:-1,y:1},{x:1,y:1}];
/* If one or more enemies */
var nearEnemies = 0;
for(var i=0;i<eNear.length;i++){
    if(Math.abs(eNear[i].x-x)+Math.abs(eNear[i].y-y)<5){
        nearEnemies++;
    }
}
if(nearEnemies >0){
    //First check whether I can beat the enemy
    for(var i=0;i<eNear.length;i++){
        for(var j=0;j<7;j++){
            if(x+Mc[j].x == eNear[i].x && y+Mc[j].y == eNear[i].y){
                return j;
            }
        }
    }

    // Else advanced tactics
    function inRangeOfNEnemies(mx,my,eNear){
        var n=0;
        for(var i=0;i<eNear.length;i++){
            if( Math.abs(my-eNear[i].y)<=1 && Math.abs(mx-eNear[i].x)==1 ){
                n=n+1;
            }

        }
        return n;
    }

    //check all all possible moves:
    var moveDangerousness = new Array(7);;
    for(var i=0;i<7;i++)moveDangerousness[i]=1/(Math.abs(x+Mc[i].x-64)+Math.abs(y+Mc[i].y-64)+1);
    //calculate dangerouseness
    for(var i=0;i<7;i++){
        moveDangerousness[i] += inRangeOfNEnemies(x+Mc[i].x,y+Mc[i].y,eNear);
    }
    //mind walls
    for(var i=0;i<7;i++){
        if(x+Mc[i].x<0 ||  x+Mc[i].x>127 || y+Mc[i].y<0 ||  y+Mc[i].y>127 ){
            moveDangerousness[i] = 9999;
        }   
    }

    var leastDangerous = moveDangerousness.indexOf(Math.min.apply(Math,moveDangerousness));
    return leastDangerous;
} else if (eNear.length>3){ //run away from enemies
    var xmean = 0;
    var ymean = 0;
    for(var i=0;i<eNear.length;i++){
        xmean += eNear[i].x*1.0/eNear.length;
        ymean += eNear[i].y*1.0/eNear.length;       
    }
    var dx = x-xmean;
    var dy = y-ymean;
    if(dx >0){
        if(dy>0){
            return Mdr;
        } else {
            return Mur;
        }
    } else {
        if(dy>0){
            return Mdl;
        } else {
            return Mul;
        }
    }

} else {//* if there are no enemies *//
    //walk pattern until you find friend, then folloow friend
    var dx = 999; var dy = 999;
    if(tNear.length>0){
        for(var i=0;i<tNear.length;i++){
            if(Math.abs(dx)+Math.abs(dy) > Math.abs(tNear[i].x-x)+Math.abs(tNear[i].y-y)){
                dx = tNear[i].x-x;
                dy = tNear[i].y-y;
            }
        }
    } else {
        dx = 64-x+10*(Math.random()-0.5);
        dy = 64-y+10*(Math.random()-0.5);
    }

    if(dx >0){
        if(dy>0){
            return Mdr;
        } else {
            return Mur;
        }
    } else {
        if(dy>0){
            return Mdl;
        } else {
            return Mul;
        }
    }
}

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


4

ब्लू टीम - Fetch [38953]

var me = 38953;
var msg = getMsg(me);
var register = msg ? JSON.parse(msg) : {};
var prevDanger = 0;
var danger;

var eScope = eNear;
var myX = x;
var myY = y;
var put = setMsg;
var get = getMsg;

function kill(){
  var move = -1;
  if(!eScope){return -1;}

  eScope.forEach(function(e){
    if(move > -1){return move;}

    var xDist = Math.abs(e.x-myX);
    var yDist = Math.abs(e.y-myY);

    if(xDist < 2 && yDist < 2){
      if(e.x == myX){
        if(e.y == myY-1){move = 2;}
        else if(e.y == myY+1){move = 1;}
      }
      else if(e.x == myX-1){
        if(e.y == myY-1){move = 4;}
        else if(e.y == myY+1){move = 5;}
      }
      else if(e.x == myX+1){
        if(e.y == myY-1){move = 3;}
        else if(e.y == myY+1){move = 6;}
      }
    }
  });

  return move;
}

function live(){
  var move = -1;
  if(!eScope){return -1;}
  var topHalf = (myY <= 64);

  eScope.forEach(function(e){
    if(move > 0){return move;} //0 on purpose; we might find a better escape

    var xDist = Math.abs(e.x-myX);
    var yDist = Math.abs(e.y-myY);

    if(xDist + yDist < 5){move = 0;}  //uh oh!  Stand still!

    if(e.y == myY){
      if(e.x == myX-1){move = (topHalf ? 5 : 4);}
      else if(e.x == myX+1){move = (topHalf ? 6 : 3);}
    }
  });

  return move;
}

function evalDanger(){
  danger = 0;

  if(register){prevDanger = register.d;}

  eScope.forEach(function(e){
    var xDist = Math.abs(e.x-myX);
    var yDist = Math.abs(e.y-myY);
    danger += ((1/yDist) * (1/xDist));
  });

  register.d = danger;
  put(JSON.stringify(register));
  return danger;
}

function distract(){
  //run to the edge if safe, to the middle if not
  var safe = (danger <= prevDanger && danger < .01);

  var topHalf = myY <= 64;
  var leftSide = myX <= 64;

  //lazy init to 'explore' mode
  if(!register.e){register.e = 1;}

  //lazy init to whatever corner we're in
  if(!register.f){
    register.f = topHalf ? leftSide ? 4 : 3 : leftSide ? 5 : 6;
  }

  //turn 'explore' on (1) or off (2);
  //if 'off' but hit 'home base', seek a corner
  if(register.e == 2 && ((myY > 54 && myY < 74) || (myX > 54 && myX < 74))){
    register.e = 1
    register.f = Math.floor(Math.random()*4)+3;
  }
  //if on the outskirts, go back to base
  if(myY < 10 || myY > 115 || myX < 10 || myX > 115){register.e = 2;}

  put(JSON.stringify(register));

  if(topHalf){
    if(leftSide){
      if(!safe || register.e == 2){return 6;}
    }
    else{
      if(!safe || register.e == 2){return 5;}
    }
  }
  else {
    if(leftSide){
      if(!safe || register.e == 2){return 3;}
    }
    else{
      if(!safe || register.e == 2){return 4;}
    }
  }
  return register.f;
}

evalDanger();
register.x = myX;
register.y = myY;

var whee = kill();
if(whee > -1){
    return whee;
}

whee = live();
if(whee > -1){
    return whee;
}

whee = distract();
return whee;

[संपादन: यह पता चलता है कि जब मैं अपनी वास्तविक आईडी का उपयोग करता हूं तो बेहतर काम करता है, न कि -1!]

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

ब्लू टोटेम कितना शक्तिशाली है, इस कारण समग्र स्कोर पर बहुत अधिक प्रभाव नहीं पड़ता है, लेकिन बहुत कम से कम मैंने चीजों को बदतर नहीं बनाया है!

यदि आप चाहते हैं कि मैं अपने संदेश में कुछ भी उपयोगी जोड़ दूं तो अगले 8 घंटे में चिल्लाएं।


ध्यान आकर्षित करने के लिए मध्य सबसे अच्छी जगह नहीं है; दुश्मनों से लड़ने के लिए कई अन्य बॉट किनारों को गोल करते दिखते हैं। शायद आपके बॉट को बीच में घेरना चाहिए?
Theonlygusti

कोनों की तुलना में बीच में बचना आसान है, लेकिन अगर आप कह रहे हैं कि मुझे टीम के साथी बीच में नहीं मिलेंगे ... ठीक है, आप सही हैं; अभी मृत्यु का मेरा # 1 कारण यह है कि मेरे करने से पहले लाल एक सहयोगी हो जाता है। अगले KotH के लिए, जब मैंने एक लक्ष्य पाया है, तो मैं मदद के लिए अन्य बॉट्स को कॉल करने की क्षमता में सुधार करने के लिए तैयार हूं!
१२:

मैं बीकन नामक बीकन पर काम कर रहा हूं; यह मेस मैदान पर हर दुश्मन और टीम के सदस्य के पदों को समाहित करेगा, और फिर अन्य दुश्मनों द्वारा ट्रैक करने और मारने के लिए इस्तेमाल किया जा सकता है या अगर टीम के साथी पर कुंडी लगा सकते हैं।
theonlygusti

4

ब्लू टीम - पैट्रोलबोट

var directionMap = {'0,0':0, '0,1':1, '1,1':6, '1,0':null, '1,-1':3, '0,-1':2, '-1,-1':4, '-1,0':null, '-1,1':5},
    direction = parseInt((getMsg(38951) || getMsg(-1) || '').slice(0, 1));

if (typeof direction !== 'number' || isNaN(direction)) direction = 0;

if (!tNear.length && !eNear.length) {
    if (!isDirection(direction) || isNearWall(12, x, y)) {
        direction = moveTowardsCoords(64, 64, x, y, directionMap, eNear);
    } else {
        direction = direction;
    }
} else if (eNear.length) {
    if (canKill(x, y, eNear, directionMap)) {
        direction = kill(x, y, eNear, directionMap);
    } else if (isNearEnemy(x, y, eNear)) {
        direction = moveToBetterPosition(x, y, eNear, directionMap);
    } else if (tNear.length + 1 >= eNear.length) {
        direction = moveTowardsEnemy(eNear, x, y, directionMap);
    } else {
        if (tNear.length) {
            direction = moveTowardsTeam(tNear, x, y, directionMap);
        } else {
            direction = moveAwayFromEnemy(eNear, x, y);
        }
    }
} else if (tNear.length && Math.random() > 0.8) {
    direction = moveTowardsTeam(tNear, x, y, directionMap);
}

setMsg((direction || 0).toString());
return direction;

function find(arr, func) {
    for (var i = 0; i < arr.length; i++) {
        if (func(arr[i])) {
            return arr[i];
        }
    }
}

function invert(obj) {
    var result = {},
        key;

    for (key in obj) {
        if (obj.hasOwnProperty(key)) {
            result[obj[key]] = key;
        }
    }

    return result;
}

function isDirection(direction) {
    return direction >= 1 && direction <= 6;
}

function isNearWall(margin, x, y) {
    return x < margin || x > (127 - margin) || y < margin || y > (127 - margin);
}

function getDistance(x1, y1, x2, y2) {
    var xd, yd;

    xd = x2 - x1;
    xd = xd * xd;

    yd = y2 - y1;
    yd = yd * yd;

    return Math.sqrt(xd + yd);
}

function getCoordDiff(x1, y1, x2, y2) {
    return [x1 - x2, y1 - y2];
}

function identifyClosest(arr, x, y) {
    var lowest = 128;

    arr = arr.map(function(i) {
        i.distance = getDistance(x, y, i.x, i.y);
        return i;
    });

    arr.forEach(function(i) {
        if (i.distance < lowest) {
            lowest = i.distance;
        }
    });

    return find(arr, function(i) {
        return i.distance === lowest;
    });
}

function identifyClosestTeam(tNear, x, y) {
    return identifyClosest(tNear, x, y);
}

function identifyClosestEnemy(eNear, x, y) {
    return identifyClosest(eNear, x, y);
}

function kill(x, y, eNear, directionMap) {
    var enemy = identifyClosestEnemy(eNear, x, y);
    return enemy ? directionMap[getCoordDiff(enemy.x, enemy.y, x, y).toString()] : 0;
}

function canKill(x, y, eNear, directionMap) {
    return !!kill(x, y, eNear, directionMap);
}

function enemyCanKill(id, x, y, eNear) {
    var arr = ['1,0', '1,1', '1,-1', '-1,0', '-1,-1', '-1,1'],
        enemy = find(eNear, function(i) {
            return i.id === id;
        });

    if (!enemy) {
        return false;
    }

    return arr.indexOf(getCoordDiff(x, y, enemy.x, enemy.y).toString()) !== -1;
}

function isNearEnemy(x, y, eNear) {
    var enemy = identifyClosestEnemy(eNear, x, y);

    if (!enemy) {
        return 0;
    }

    return Math.max.apply(null, getCoordDiff(x, y, enemy.x, enemy.y).map(function(i){
        return Math.abs(i);
    })) <= 2;
}

function isIntoWall(dx, dy) {
    return dx > 127 || dx < 0 || dy > 127 || dy < 0;
}

/**
 * Picks a random direction heading towards {dx, dy}
 */
function moveTowardsCoords(destX, destY, oldX, oldY, directionMap, eNear) {
    return changeDirection(function(newX, newY) {
        return getDistance(oldX, oldY, destX, destY) - getDistance(newX, newY, destX, destY);
    }, oldX, oldY, eNear, directionMap);
}


function changeDirection (scoringFunction, x, y, eNear, directionMap) {
    var highest = 0,
        validDirections = (function() {
            var result = {};
            for (var key in directionMap) {
                if (directionMap.hasOwnProperty(key) && directionMap[key] !== null) {
                    result[key] = directionMap[key];
                }
            }
            return result;
        })(),
        coords = Object.keys(validDirections).map(function(i) {
            var result = {
                    vector: i,
                    score: 0
                },
                xy = i.split(',').map(function(term, i) {
                    return parseInt(term) + (i === 0 ? x : y);
                });

            result.x = xy[0];
            result.y = xy[1];

            result.score = scoringFunction(result.x, result.y, eNear, directionMap);

            if (result.score > highest) {
                highest = result.score;
            }

            return result;
        }),
        arr = coords.filter(function(i) {
            return i.score === highest;
        });

    var num = Math.floor(Math.random() * arr.length);

    return validDirections[arr[num].vector];
}

function moveTowards(id, x, y, tNear, eNear, directionMap) {
    var target = find([].concat(tNear, eNear), function(i) {
        return i.id === id;
    });

    if (target) {
        return moveTowardsCoords(target.x, target.y, x, y, directionMap, eNear);
    } else {
        return 0;
    }
}

function moveTowardsEnemy(eNear, x, y, directionMap) {
    var enemy = identifyClosestEnemy(eNear, x, y);

    return enemy ? moveTowards(enemy.id, x, y, [], eNear, directionMap) : 0;
}

function moveTowardsTeam(tNear, x, y, directionMap) {
    var team = identifyClosestTeam(tNear, x, y);

    return team ? moveTowards(team.id, x, y, tNear, [], directionMap) : 0;
}

function moveAwayFromEnemy(eNear, x, y) {
    var oppositeMap = {
        0: 0,
        1: 2,
        2: 1,
        3: 5,
        4: 6,
        5: 3,
        6: 4
    };
    return oppositeMap[moveTowardsEnemy(eNear, x, y, directionMap)];
}

/**
 * Gives points to each move based on three metrics:
 * 
 * 2) will not cause us to be killed next turn
 * 1) will let us kill next turn
 * 
 * Then randomly picks from the highest scoring moves
 */
function moveToBetterPosition(x, y, eNear, directionMap) {
    return changeDirection(function(x, y, eNear, directionMap) {
        var score = 0;

        if (canKill(x, y, eNear, directionMap)) {
            score += 1;
        }

        if (!eNear.some(function(e) {
                return enemyCanKill(e.id, x, y, eNear);
            })) {
            score += 2;
        }

        if (isIntoWall(x, y)) {
            score = 0;
        }

        return score;
    }, x, y, eNear, directionMap);
}

कोड स्व-दस्तावेजीकरण की तरह है। पैट्रोलबोट को सुधारने के लिए जो चीजें की जा सकती थीं

  • प्रतिक्षेपक - सब कुछ IIFE में ले जाएं, चर को बंद करने के बजाय बीस मैजिलियन बार से गुजरने का उपयोग करें।
  • if (canBeKilled() || isInWall()) { moveToBetterPosition() }वापसी से ठीक पहले जोड़ें ।
  • एक दीवार के बगल में टीम के सदस्य का पालन करते समय बुरे व्यवहार को साफ करें।
  • टीम के सदस्यों पर उतरने से बचें।
  • लगातार 200 घुमावों के लिए लगे रहने पर दुश्मन से दूर हो जाएं।

यह एक बहुत अच्छा बॉट है। बहुत बढ़िया। यहां 100-राउंड रन के परिणाम दिए गए हैं: chat.stackexchange.com/transcript/message/20949696#20949696
PhiNotPi

2

ब्लू टीम - 1 अंक बहुत बढ़िया

//  1PointAwesome by Grant Davis

var myid=38941; //My ID for getMsg()

var result=0;
var leeway=1; //How close to follow enemy
var gForce=3; //How strongly gravity effects x/y
var futureDanger=true;
//Modifier Random Generation
var newX=Math.floor(Math.random()*3-1);
var newY=Math.floor(Math.random()*3-1);
var random10=Math.floor(Math.random()*2);

var dangerArray=[[false,false,false],[false,false,false],[false,false,false]];
var gravityX,gravityY,antiGravityX,antiGravityY;

//Sets defaults: gravity center
if(move==1){setMsg("64,64");}

//Change gravity when you have reached within 5 of gravity
if(eNear.length==0){
 if(Math.floor(Math.random()*2)==0){
  if(parseInt(getMsg(myid).split(",")[0])-x<5&&parseInt(getMsg(myid).split(",")[0])-x>-5){setMsg(Math.floor(Math.random()*32)+","+getMsg(myid).split(",")[1]);}
  if(parseInt(getMsg(myid).split(",")[1])-y<5&&parseInt(getMsg(myid).split(",")[1])-y>-5){setMsg(getMsg(myid).split(",")[0]+","+Math.floor(Math.random()*32));}
 }else{
  if(parseInt(getMsg(myid).split(",")[0])-x<5&&parseInt(getMsg(myid).split(",")[0])-x>-5){setMsg(Math.floor(Math.random()*32+96)+","+getMsg(myid).split(",")[1]);}
  if(parseInt(getMsg(myid).split(",")[1])-y<5&&parseInt(getMsg(myid).split(",")[1])-y>-5){setMsg(getMsg(myid).split(",")[0]+","+Math.floor(Math.random()*32+96));}
 }
}

//Pulls gravity from getMsg() and converts it into variables readable by the program
if(x<parseInt(getMsg(myid).split(",")[0])+Math.floor(Math.random()*30-15)){gravityX=1;antiGravityX=-1;}else{gravityX=-1;antiGravityX=1;}
if(y<parseInt(getMsg(myid).split(",")[1])+Math.floor(Math.random()*30-15)){gravityY=-1;antiGravityY=1;}else{gravityY=1;antiGravityY=-1;}

//Modifier Random Generation, Gravity bias.
if(Math.floor(Math.random()*gForce)!=0||x<31&&eNear.length==0||x>95&&eNear.length==0){newX=gravityX;}
if(Math.floor(Math.random()*gForce)!=0||y<31&&eNear.length==0||y>95&&eNear.length==0){newY=gravityY;}


//Avoid edges modifier:
//Sets gravity to 64,64 when within 32 of an edge

if(y<31&&eNear.length==0||y>95&&eNear.length==0){setMsg(getMsg(myid).split(",")[0]+",64");}
if(x<31&&eNear.length==0||x>95&&eNear.length==0){setMsg("64,"+getMsg(myid).split(",")[1]);}

//Targeting Modifier:
//Does not modify if outnumbered
//Tries to attack from above or below
//If enemy escapes: look where the enemy was last at
//Reset gravity if all targets

if(eNear.length<=tNear.length+1&&eNear.length!=0){

setMsg(eNear[0]["x"]+","+eNear[0]["y"]);
if(eNear[0]["x"]>x){newX=1;}else if(eNear[0]["x"]<x){newX=-1;}else{newX=0;}
if(eNear[0]["y"]>y+leeway){newY=-1;}else if(eNear[0]["y"]<y-leeway){newY=1;}
}



//Anti loop Modifier: Removed due to minor strategy flaw


//If I can get above or below a pixel, do it 


//If I can kill an enemy pixel, kill it
for(var ep=0;eNear.length>ep;ep+=1){

 if(eNear[ep]["x"]==x&&eNear[ep]["y"]-y==1){newY=-1;newX=0;}
 else if(eNear[ep]["x"]==x&&eNear[ep]["y"]-y==-1){newY=1;newX=0;}
 else if(eNear[ep]["x"]-x==-1){
  if(eNear[ep]["y"]-y==1){newX=-1;newY=-1;}
  else if(eNear[ep]["y"]-y==-1){newX=-1;newY=1;}
 }
 else if(eNear[ep]["x"]-x==1){
  if(eNear[ep]["y"]-y==1){newX=1;newY=-1;}
  else if(eNear[ep]["y"]-y==-1){newX=1;newY=1;}
 }
}

//Not allowed to move off screen.
if(x==0){for(var i=0;i<=2;i+=1){dangerArray[0][i]==true;}}
if(x==127){for(var i=0;i<=2;i+=1){dangerArray[2][i]==true;}}
if(y==0){for(var i=0;i<=2;i+=1){dangerArray[i][0]==true;}}
if(y==127){for(var i=0;i<=2;i+=1){dangerArray[i][2]==true;}}

var originalNewX=newX;
var originalNewY=newY;






//Double checks movement made by previous code, and then turns it into a number that Pixel Team Battlebots can read
for(var antiloop=0;futureDanger&&antiloop<20;antiloop+=1){

 futureDanger=false;


 //When bot tries to move left or right, it will move diagonal.
 if(newX!=0&&newY==0){
  newY=Math.floor(Math.random()*2);
  if(newY==0){newY=-1;}
 }


 if(eNear.length>0){ //Protocol Paranoid: When pixel attempts to move into dangerous square, The pixel will move into a different square, and recheck danger.




  for(var ep=0;ep<eNear.length;ep+=1){ //Checks for the danger level of the square pixel attempts to move in.

   if(Math.abs(eNear[ep]["x"]-(x+newX))==1 && eNear[ep]["y"]-(y-newY)<=1 && eNear[ep]["y"]-(y-newY)>=-1){
    futureDanger=true;

    dangerArray[newX+1][Math.abs(newY-1)]=true;
    if(dangerArray[1][1]==false){newX=0;newY=0;}//When attempt to move into dangerous square, do nothing
    else if(dangerArray[gravityX+1][gravityY+1]==false){newX=gravityX;newY=gravityY;}
    else if(dangerArray[antiGravityX+1][gravityY+1]==false){newX=antiGravityX;newY=gravityY;random10=1;}
    else if(dangerArray[gravityX+1][antiGravityY+1]==false){newX=gravityX;newY=antiGravityY;random10=0;}

    else if(dangerArray[antiGravityX+1][antiGravityY+1]==false){newX=antiGravityX;newY=antiGravityY;}
    else if(dangerArray[1][gravityY+1]==false){newX=0;newY=gravityY;}
    else if(dangerArray[1][antiGravityY+1]==false){newX=0;newY=antiGravityY;}
    else{newX=originalX;newY=originalY;}
   }
  }
 }else//End of Protocol Paranoid

 if(antiloop==18){newX=originalNewX;NewY=originalNewY;}

}//Big for end


if(newY==1){result=2;}else if(newY==-1){result=1;}

if(newX==1){if(result==2){result=3;}else if(result==1){result=6;}}else if(newX==-1){if(result==2){result=4;}else if(result==1){result=5;}}



return result;

पिक्सेल की प्राथमिकताएँ:

  • कभी भी खतरनाक स्थानों में नहीं जाना चाहिए (बाध्य स्थानों में से खतरनाक माना जाता है)
  • मार सके तो सक्षम
  • शत्रु की ओर बढ़ें (ईएनआरईआर में पहला) जब तक कि वह आगे नहीं निकला
  • किनारों से दूर हटो
  • अंतिम ज्ञात स्थान पर दुश्मनों के पास जाएं
  • जहां गुरुत्वाकर्षण स्थित है वहां जाएं

चाल 1 पर गुरुत्वाकर्षण 64,64 पर सेट है

गुरुत्वाकर्षण निकटतम शत्रु स्थान पर सेट है (यदि शत्रु बच जाए तो पिक्सेल को अंतिम शत्रु के स्थान पर निर्देशित करने के लिए)

जब पिक्सेल गुरुत्वाकर्षण के केंद्र पर या किनारे के पास पहुंच जाता है तो गुरुत्वाकर्षण में बेतरतीब बदलाव होता है


2

रेड - लॉयलफ़्लोर [15080]

var dangerValues = {
    killEnemy:      -110,
    killMe:          160,
    nearEnemy:       -20,
    killPair:       -200,
    friendIsThere:    30,
    outside:         999,
    nearWall:         10,
    wayToMinos:       -2,
    wayToFriend:      -1,
    wayToEnemy:       -4,
    wayToManyEnemies:  3
};

var moves = [
    {newX: x, newY: y, danger: 0},
    {newX: x + 1, newY: y, danger: 0},
    {newX: x - 1, newY: y, danger: 0},
    {newX: x + 1, newY: y - 1, danger: 0},
    {newX: x - 1, newY: y - 1, danger: 0},
    {newX: x - 1, newY: y + 1, danger: 0},
    {newX: x + 1, newY: y + 1, danger: 0}
];
var closestEnemy = null;
var closestFriend = null;

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

var meKillable = function(meX, meY, himX, himY) {
    return (Math.abs(meY - himY) === 1 && Math.abs(meX - himX) <= 1);
};

var enemyKillable = function(meX, meY, himX, himY) {
    return (Math.abs(meX - himX) === 1 && Math.abs(meY - himY) <= 1);
};

for (i = 0; i < moves.length; i++) {
    if (moves[i].newX < 0 || moves[i].newY < 0 || moves[i].newX > 127 || moves[i].newY > 127) {
        moves[i].danger = dangerValues.outside;
    }
    if (moves[i].newX === 0 || moves[i].newX === 127 || moves[i].newY === 0 || moves[i].newY === 127) {
        moves[i].danger += dangerValues.nearWall;
    }
    for (var j = 0; j < eNear.length; j++) {
        if (closestEnemy === null || distance(x, y, closestEnemy.x, closestEnemy.y) > distance(x, y, eNear[j].x, eNear[j].y)) {
            closestEnemy = eNear[i];
        }

        if (moves[i].newX === eNear[j].x && moves[i].newY === eNear[j].y) {
            if (eNear[j].id === 21487 || eNear[j].id === 2867) {
                moves[i].danger += dangerValues.killPair;
            } else {            
                moves[i].danger += dangerValues.killEnemy;
            }
        }
        if (meKillable(moves[i].newX, moves[i].newY, eNear[j].x, eNear[j].y)) {
            moves[i].danger += dangerValues.killMe;
        }
        if (enemyKillable(moves[i].newX, moves[i].newY, eNear[j].x, eNear[j].y)) {
            moves[i].danger += dangerValues.nearEnemy;
        }
    }
    for (var j = 0; j < tNear.length; j++) {
        if (closestFriend === null || distance(x, y, closestFriend.x, closestFriend.y) > distance(x, y, tNear[j].x, tNear[j].y)) {
            closestFriend = tNear[i];
        }
        if (moves[i].newX === tNear[j].x && moves[i].newY === tNear[j].y) {
            moves[i].danger += dangerValues.friendIsThere;
        }
    }
}

var bestDistanceToMinos = 200;
var minos = 38926;
var minosMsg = getMsg(minos);
var manyEnemies = eNear.length > tNear.length;
if (minosMsg !== '' && minosMsg !== undefined) {
    minosMsg = minosMsg.split(";");
    var minosPos = {posX: parseInt(minosMsg[0], 10), posY: parseInt(minosMsg[1], 10)};
    for (i = 0; i < moves.length; i++) {
        var distanceToMinos = distance(moves[i].newX, moves[i].newY, minosPos.posX, minosPos.posY);
        if (distanceToMinos < bestDistanceToMinos) {
            bestDistanceToMinos = distanceToMinos;
        }       
    }
}
for (i = 0; i < moves.length; i++) {
    if (minosMsg !== '' && minosMsg !== undefined) {
        var distanceToMinos = distance(moves[i].newX, moves[i].newY, minosPos.posX, minosPos.posY);
        if (distanceToMinos === bestDistanceToMinos) {
            moves[i].danger += dangerValues.wayToMinos;
        }
    }
    if (closestFriend != null && distance(moves[i].x, moves[i].y, closestFriend.x, closestFriend.y) < distance(x, y, closestFriend.x, closestFriend.y)) {
        moves[i].danger += dangerValues.wayToFriend;
    }

    if (closestEnemy != null && distance(moves[i].x, moves[i].y, closestEnemy.x, closestEnemy.y) < distance(x, y, closestEnemy.x, closestEnemy.y)) {
        moves[i].danger += manyEnemies ? dangerValues.wayToManyEnemies : dangerValues.wayToEnemy;
    }
}

var bestMove = null;
var leastDanger = 10000;
for (i = 0; i < moves.length; i++) {
    if (moves[i].danger < leastDanger || (moves[i].danger === leastDanger && Math.random() < 0.5)) {
        leastDanger = moves[i].danger;
        bestMove = i;
    }
}
var newX = ("000" + moves[bestMove].newX).substr(-3, 3);
var newY = ("000" + moves[bestMove].newY).substr(-3, 3);
setMsg(newX + ";" + newY);
return bestMove;

मिनोस को खोजने और दुश्मनों को मारने की कोशिश करता है। अफसोस की बात है, लाल टीम अभी भी हारती है, शायद इसलिए कि हम कम खिलाड़ी हैं ...


2

ब्लू टीम - मिडिलमैन

// MiddleMan by Mwr247

// Self identification
var id = 30793;

// Bounds
var minPos = 0;
var midPos = 63;
var maxPos = 127;

// Movesets
var up = [0, 4, 2, 3, 5, 1, 6];
var down = [0, 5, 1, 6, 4, 2, 3];
var left = [0, 4, 5, 2, 1, 3, 6];
var right = [0, 3, 6, 2, 1, 4, 5];

// Our grid
var points = [0, 0, 0, 0, 0, 0, 0];

// Point system
var bound = -100000;
var death = -5000;
var dodge = 500;
var evade_best = 100;
var evade_better = 50;
var evade_good = 25;
var evade_bad = -25;
var evade_worse = -50;
var evade_worst = -100;
var kill = 4900;
var enemy = 5;

// Message
var msg = [[], []];

// Normalize values
var norm = function(val) {
    return Math.max(-1, Math.min(1, Math.round(val)));
};

// Get detailed ent data
var data = function(ent) {
    var info = {};
    info.x = ent.x - x;
    info.y = ent.y - y;
    info.normX = norm(info.x);
    info.normY = norm(info.y);
    info.distX = Math.abs(info.x);
    info.distY = Math.abs(info.y),
    info.dist = Math.sqrt(Math.pow(info.x, 2) + Math.pow(info.y, 2))
    return info
};

// Set position value
var pos = function(dir, index, val) {
    points[dir[index]] += val;
};

// Set position value above/below
var ver = function(dir, val) {
    pos(dir, 1, val);
    pos(dir, 2, val * 1.001);
    pos(dir, 3, val);
};

// Set position value on the sides
var hor = function(dir, val) {
    pos(dir, 1, val);
    pos(dir, 2, val);
};

// Vertical bound logic
if (y === minPos) {
    ver(up, bound);
} else if (y === maxPos) {
    ver(down, bound);
}

// Horizontal bound logic
if (x === minPos) {
    hor(left, bound);
} else if (x === maxPos) {
    hor(right, bound);
}

// Enemy logic
if (eNear.length) {
    var tmp;
    for (var i = 0; i < eNear.length; i++) {
        // Add the enemy to the message data
        msg[1].push([eNear[i].x, eNear[i].y]);
        tmp = data(eNear[i]);
        // We're touching, either attack or evade
        if (tmp.distY <= 1 && tmp.distX <= 1) {
            var d;
            if (tmp.distX !== 0) { // If we are not right above/below, current position is a death zone
                pos(up, 0, death);
            }
            if (tmp.distY === 0) { // Dodge like heck
                if (tmp.normX > 0) {
                    hor(right, dodge);
                    hor(left, evade_best);
                } else if (tmp.normX < 0) {
                    hor(left, dodge);
                    hor(right, evade_best);
                }
                pos(up, 2, death);
                pos(down, 2, death);
            } else { // We are above or below; finish them!
                d = tmp.y > 0 ? down : up;
                pos(d, 2 + tmp.normX, kill);
                if (tmp.normX === 0) {
                    pos(d, 1, death);
                    pos(d, 3, death);
                } else {
                    pos(d, 2, death);
                }
            }
        } else if (tmp.distY <= 2 && tmp.distX <= 2) { // We're a spot away, don't get too close!
            var d;
            if (tmp.distY === 2) { // They are two below
                d = tmp.y === 2 ? down : up;
                if (tmp.distX === 0) { // Straight down
                    pos(d, 1, death);
                    pos(d, 3, death);
                    pos(d, 2, dodge);
                    pos(d, 5, evade_good);
                    pos(d, 0, evade_best);
                } else if (tmp.distX === 1) { // One to the side
                    pos(d, 2, death);
                    pos(d, 2 + tmp.normX, dodge);
                    pos(d, 5 + tmp.normX, evade_better);
                    pos(d, 5 - tmp.normX, evade_bad);
                    pos(d, 2 - tmp.normX, evade_worst);
                } else { // Diagonals
                    pos(d, 2 + tmp.normX, death);
                    pos(d, 5 + tmp.normX, evade_better);
                    pos(d, 5 - tmp.normX, evade_bad);
                    pos(d, 2, evade_worse);
                    pos(d, 2 - tmp.normX, evade_worst);
                }
            } else { // They are to the sides
                d = tmp.normX === 1 ? right : left;
                if (tmp.distY === 0) { // Straight out
                    hor(d, death);
                    pos(d, 3, evade_better);
                    pos(d, 4, evade_better);
                } else { // A little angled
                    pos(d, 1 + (tmp.normY > 0), death);
                    pos(d, 1 + (tmp.normY < 0), evade_best);
                }
            }
        }

        // If there's a horizontal enemy, head that way
        if (tmp.x > 0) {
            hor(right, enemy + 16 - tmp.x);
        } else if (tmp.x < 0) {
            hor(left, enemy + 16 - tmp.x);
        }
        // If there's a vertical enemy, head that way
        if (tmp.y > 0) {
            ver(down, enemy + 16 - tmp.y);
        } else if (tmp.y < 0) {
            ver(up, enemy + 16 - tmp.y);
        }
    }

    // If we're near an enemy, lets try to bring them towards our friends
    if (tNear.length) {
        for (var i = 0; i < tNear.length; i++) {
            tmp = data(tNear[i]);
            if (tmp.x > 0) { // Horizontal moves
                hor(right, 1 + (16 - tmp.x) / 4);
            } else if (tmp.x < 0) {
                hor(left, 1 + (16 - tmp.x) / 4);
            }
            if (tmp.y > 0) { // Vertical moves
                ver(down, 1 + (16 - tmp.y) / 4);
            } else if (tmp.y < 0) {
                ver(up, 1 + (16 - tmp.y) / 4);
            }
        }
    }
}

// If not fighting, be the middleman you really want to be
if (y < midPos) {
    ver(down, 1);
} else if (y > midPos) {
    ver(up, 1);
}

// Hang around the horizontal middle, safe from those nasty corners
if (x < midPos) {
    hor(right, 1);
} else if (x > midPos) {
    hor(left, 1);
} else {
    pos(up, 0, 0.1);
}

// Evaluate our grid and find the winning move
var max = 0;
for (var i = 1; i < points.length; i++) {
    // If a clear winner, go with that. If there's a tie, randomize to keep things fresh
    if (points[max] < points[i] || (points[max] === points[i] && Math.round(Math.random()))) {
        max = i;
    }
}

// Set our new coordinates
var nX = x + (max === 3 || max === 6) - (max === 4 || max === 5);
var nY = y + (max === 5 || max === 1 || max === 6) - (max === 4 || max === 2 || max === 1);
msg[0] = [nX, nY];

// Set our message
setMsg(JSON.stringify(msg));

// Return the highest value move
return max;

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

खबरदार, लाल टीम। जबकि वह ज्यादा प्रतीत नहीं हो सकता है, वह उतना ही उग्र और लगातार है जितना वे आते हैं; करीबी लड़ाई का एक मास्टर। वह अपनी टीम के साथ सीधे संवाद नहीं कर सकता है, लेकिन वह उन्हें स्वीकार करता है, और आम दुश्मन को उतारने के लिए मिलकर काम करेगा। उसने हाल ही में संदेश भेजने का तरीका सीखा है, हालाँकि वह किसी की भी बात नहीं सुनेगा, सिर्फ उसकी शैली की नहीं। प्रारूप एक JSON स्ट्रिंग है जिसमें इस तरह की एक सरणी है: [[selfX,selfY],[[enemy1X,enemy1Y],[enemy2X,enemy2Y]]]और इतने पर और अधिक दुश्मनों के लिए।


1

ब्लू टीम - VersaBot, एक बहुरूपी इंजन

मेरा कोड स्वचालित रूप से इसके पास के निकटतम बॉट का पालन करेगा, अतिरिक्त गोलाबारी और सुरक्षा प्रदान करेगा।

// VersaBot - The PolyMorphic Companion
// Copyright 2017.5 Sam Weaver
// For this SO challenge: http://codegolf.stackexchange.com/questions/48353/red-vs-blue-pixel-team-battlebots

//FUNctions
var randInt = function(min,max) {return Math.floor((Math.random() * ((max + 1) - min)) + min);};
var degrees = function(radians) {return radians * 180 / Math.PI;};

//variables
var me = 31743;
var friendId;

if(getMsg(me) == '') {
    friendId = 0;
    setMsg(friendId);
} else {
    friendId = getMsg(me);
}

//first, check if any teammates nearby
if(tNear.length > 0) {
    //loop through and see if friend is found
    var found = false;
    var fx,fy;
    for(var index in tNear) {
        var nearAlly = tNear[index];
        //check if friend
        if(nearAlly.id == friendId) {
            //yay, let's follow 'em
            fx = nearAlly.x;
            fy = nearAlly.y;
            found = true;
            break;
        }
    }
    if(!found) {
        //pick the first friend to be a new friend
        friendId = tNear[0].id;
        fx = tNear[0].x;
        fy = tNear[0].y;
    }

    //NOW, let's follow'em
    //get the radian angle in relation to me
    var radAngle = Math.atan2(fy-y,fx-x);
    //to degrees we go!
    //console.log('friend');
    var deg = Math.floor(degrees(radAngle));
    //now reverse it so it works
    deg = -1*deg;


    //we can return the right direction now
    if(deg > 120) {
        return 4; //up left
    } else if(deg > 60) {
        return 2; //up
    } else if(deg > 0) {
        return 3; //up right
    } else if(deg < -120) {
        return 5; //down left
    } else if(deg < -60) {
        return 1; //down
    } else if(deg < 0) {
        return 6; //down right
    }
    //for some reason?
    return 0;

} else {
    //pick a random direction
    return randInt(1,6);
}

का आनंद लें!

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