লাল বনাম নীল - পিক্সেল টিম ব্যাটলবট


133

এই প্রতিযোগিতাটি সরকারীভাবে শেষ হয়েছে। জিতেছে নীল দল!

আমি 50 টি যুদ্ধের দুটি সেট অটোরান করেছি এবং আশ্চর্যরকমভাবে, নীল তাদের 100 টি জিতেছে। পরিসংখ্যানগুলির দিকে তাকালে, স্পষ্ট হয় যে ফিনোটপি এবং এসপি 3000 এর সমবায় এন্ট্রিগুলি আসল নায়ক ছিল। দুর্দান্ত কাজ আপনি দুজন! আসলে, আপনি যদি নীল দলের প্রত্যেকটি সদস্যকে অযোগ্য ঘোষণা করেন তবে স্পিবিটস এখনও একটি খুব ভাল লড়াই চালিয়ে যাবে । কিছু রেড টিমের লোকেরা স্পিবিটগুলি নামানোর পরিকল্পনা করছিল, তবে এই প্রচেষ্টাটি শেষ হয়ে গেছে বলে মনে হয়েছিল। দুঃখিত রেড দল।

প্রতিযোগিতাটি আনুষ্ঠানিকভাবে শেষ হয়েছে, তবে এর অর্থ এই নয় যে আপনি আর উত্তর দিতে পারবেন না, এর অর্থ কেবলমাত্র আমি সরকারী বিজয়ীকে পুনরায় ঘোষনা করব না। উভয় দলই কেবল বিনোদনের জন্য বট জমা দেওয়ার জন্য স্বাগত। নিয়ামক যতক্ষণ না ভবিষ্যতে কোনও এন্ট্রিগুলি ভঙ্গ করে না ততক্ষণ পর্যন্ত কার্যকর থাকবে।


এটি একটি পাহাড়ের কিংবদন্তি প্রতিযোগিতা, তবে প্রত্যেকে একে অপরের বিরুদ্ধে লড়াইয়ের পরিবর্তে দুটি দল হবে প্রতিযোগিতা: লাল এবং নীল। কেবল একজনই বিজয়ী হবেন।

আপনি যে দলটির উপরে রয়েছেন তা আপনার পিপিসিজি ব্যবহারকারী আইডি নম্বরের উপর নির্ভর করে । এটি সন্ধানের জন্য, পর্দার শীর্ষে আপনার অবতারটি ক্লিক করুন (আপনাকে অবশ্যই লগ ইন করতে হবে) এবং খোলার পৃষ্ঠার ইউআরএলটি দেখুন। এর পরে নম্বরটি users/আপনার আইডি নম্বর:

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

উদাহরণস্বরূপ, আমার পিপিসিজি ব্যবহারকারী আইডি নম্বরটি 26997:

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

নোট করুন যে এই সংখ্যাটি বিভিন্ন স্ট্যাক এক্সচেঞ্জ সাইটের জন্য পৃথক।

আপনার আইডি যদি একটি সমান নম্বর হয় তবে আপনি রেড দলে রয়েছেন ।
যদি আপনার আইডি একটি বিজোড় নম্বর হয় তবে আপনি নীল দলে রয়েছেন ।
দল বদলানোর কোনও উপায় নেই।

আপনি আপনার টিমের সাথে কাজ করে এমন সাজানোর মধ্যে অন্য দলের সর্বনাশ চেষ্টা করতে হবে যুদ্ধ রাজকীয় যেখানে প্রত্যেক ব্যবহারকারী একটি 128 × 128 গ্রিড যুদ্ধক্ষেত্র যে তাদের দলের রং এর "পিক্সেল" নিয়ন্ত্রণ করে। পিক্সেলগুলি ঘোরাফেরা করতে পারে, তাদের সতীর্থদের সাথে যোগাযোগ করতে পারে এবং অন্য দলের পিক্সেলগুলি বের করতে পারে। যদি কেউ কোনও সংখ্যক পিক্সেল তৈরি করতে পারে তবে এটি হাতছাড়া হয়ে যাবে, সুতরাং প্রতিটি ব্যবহারকারী কেবল এই প্রশ্নের একটি উত্তর জমা দিতে পারে।

এই স্ট্যাক স্নিপেট ( পুরো এই প্রতিযোগিতার জন্য এই ফুলের একটি সম্পূর্ণ সংস্করণ [ পূর্ণস্ক্রিন ]) ler এটি স্বয়ংক্রিয়ভাবে জমাগুলি পড়ে, তা বৈধ কিনা তা নিশ্চিত করে এবং দলগুলির মধ্যে লড়াই শুরু করে। এটি জাভাস্ক্রিপ্ট ব্যবহার করে যে কোনও সময় আপনার ব্রাউজারে এটি করতে পারে । যেহেতু জাভাস্ক্রিপ্ট হ'ল একমাত্র ক্লায়েন্ট-সাইড স্ক্রিপ্টিং ভাষা বেশিরভাগ ব্রাউজার সমর্থন করে, তাই সমস্ত জমাটি অবশ্যই জাভাস্ক্রিপ্টে লিখতে হবে।

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 চাল চালায় (যদি খেলাটি শেষ না হয়)।

যে দলটি প্রথমে সরে যেতে পারে সেটি হ'ল একটি বিকল্প যা আপনাকে অবশ্যই নিয়ামকের মধ্যে সেট করতে হবে।
যুদ্ধগুলি যখন অটোোরান হয়, তখন যে দলটি প্রতিটি যুদ্ধে প্রথম বিকল্পে চলে যায়।

প্লেয়ার মুভস

যখন কোনও দল নড়াচড়া করে, তখন সেই দলের সমস্ত খেলোয়াড়কে নিজেরাই সরানোর জন্য আহ্বান জানানো হয়। এই কলগুলি প্রতিটি পদক্ষেপের জন্য সম্পূর্ণ এলোমেলো ক্রমে করা হয়। যখন ডাকা হয়, প্রতিটি খেলোয়াড়কে যুদ্ধের অবস্থা সম্পর্কে ডেটা দেওয়া হয় যাতে তারা সিদ্ধান্ত নিতে পারে যে কোন পথে সরানো যায়।

সমস্ত চালগুলি কেবল এক পিক্সেল দূরে। এই চিত্রগুলির অন্ধকার চেনাশোনাগুলি চিহ্নিত করে যে প্রতিটি রঙিন প্লেয়ার (স্কোয়ারগুলি) যেতে পারে:

লাল দল চিত্রটি সরায় moves নীল দল চিত্রটি সরায় moves

উভয় রঙই যে কোনও দিকে তির্যকভাবে অগ্রসর হতে পারে বা স্থির থাকতে পারে, তবে কেবলমাত্র লাল প্লেয়ারগুলি ডান এবং বাম দিকে যেতে পারে এবং কেবল নীল খেলোয়াড়ই নীচে এবং উপরে যেতে পারে। ধন্যবাদ ফি ও অন্যান্য

কোনও খেলোয়াড় যদি যুদ্ধক্ষেত্রের সীমানা থেকে সরে যাওয়ার চেষ্টা করে, বা কোন পথে যেতে হবে সে সিদ্ধান্ত নিতে খুব বেশি সময় নেয় বা কোনওরকম ত্রুটি থাকে তবে তারা স্বয়ংক্রিয়ভাবে স্থির থাকবে।

চলার পাশাপাশি, কোনও পালা চলাকালীন কোনও প্লেয়ার তাদের সতীর্থদের লেখা বার্তা পড়তে এবং বার্তাগুলি লিখতে পারে যা ঘুরে দেখা যায়। এটি টিম যোগাযোগের একটি অশোধিত ফর্মের জন্য অনুমতি দেয়।

উত্তর হিসাবে আপনি যে কোডটি জমা দিচ্ছেন তা হ'ল যুক্তি যা আপনার প্লেয়ারকে কীভাবে সরানো যায় এবং কোন বার্তা পড়তে এবং লিখতে হবে তা নির্ধারণ করে ( "কীভাবে উত্তর দিতে হবে" দেখুন )।

শত্রু খেলোয়াড়দের সরানো হচ্ছে

যখন কোনও খেলোয়াড় প্রতিপক্ষ দলের একজন খেলোয়াড়ের মতো একই কক্ষে চলে যায়, তখন বিরোধী খেলোয়াড়কে তত্ক্ষণাত যুদ্ধ থেকে সরিয়ে দেওয়া হয়। সবেমাত্র প্লেয়ারটি সরানো স্বাভাবিক হিসাবে চালিয়ে যায়। এটিই একমাত্র প্রক্রিয়া যা খেলোয়াড়দের যুদ্ধ থেকে সরিয়ে দেয় এবং এটি মাস্টারিংই জয়ের চাবিকাঠি!

সেলে যদি একাধিক শত্রু প্লেয়ার থাকে তবে কোনও প্লেয়ার সবেমাত্র সরে গেছে তবে সমস্ত শত্রু খেলোয়াড় সরানো হবে। একই দলের দুজন খেলোয়াড় একই কক্ষ দখল করলে কিছুই হয় না।

একটি যুদ্ধ জয়

সমস্ত যুদ্ধের একবার 2030 টি পদক্ষেপ নেওয়া বা যখন একটি দলের কোনও খেলোয়াড় বাকি না থাকে তখন যুদ্ধ শেষ হয়। বেঁচে থাকা খেলোয়াড়দের সর্বাধিক সংখ্যক দল জয়ী দল। এটি উভয় দলেরই যদি সমান সংখ্যক বেঁচে থাকা খেলোয়াড় থাকে তবে এটি সমান।

কিভাবে উত্তর দিতে হবে

আপনার উত্তরে, আপনাকে জাভাস্ক্রিপ্ট কোড সরবরাহ করতে হবে যা সিদ্ধান্ত নেবে যে কখন আপনার পিক্সেলটি চলবে।

ইন প্রথম আপনার উত্তর (বেশী 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 আপনার বর্তমান এক্স অবস্থান, 0 (বামতম) থেকে 127 (ডানেদিকের) থেকে পূর্ণসংখ্যা
  • y আপনার বর্তমান y অবস্থান, 0 (শীর্ষস্থানীয়) থেকে 127 (নীচে) এর পূর্ণসংখ্যা
  • tCount আপনার দলে বেঁচে থাকা খেলোয়াড়দের বর্তমান মোট সংখ্যা।
  • eCount শত্রু দলে বেঁচে থাকা মোট খেলোয়াড়ের বর্তমান সংখ্যা।
  • tNearআপনার দলের বর্তমান বেঁচে থাকা খেলোয়াড়দের একটি তালিকা যা 16 পিক্সেলের চেয়ে কম দূরে (ইউক্লিডিয়ান দূরত্ব)। প্রত্যেকটি উপাদান tNearসঙ্গে একটি অবজেক্ট x, yএবং idবৈশিষ্ট্য:
    • x অন্যান্য প্লেয়ারের এক্স পজিশন
    • y অন্য প্লেয়ারের ওয়াই পজিশন
    • id অন্যান্য প্লেয়ারের পিপিসিজি ব্যবহারকারী আইডি নম্বর (পূর্ণসংখ্যা হিসাবে)
  • eNearএকেবারে tNearশত্রু খেলোয়াড়দের নয়, কাছের শত্রু খেলোয়াড়ের তালিকা বাদে ঠিক এটির মতো ।

স্নিপেটের চেনাশোনাগুলি প্রতিটি প্লেয়ার tNearএবং eNearব্যাপ্তি।

বার্তা

শেষ 2 পরামিতি, setMsgএবং getMsg, কিছুটা ভিন্ন উদ্দেশ্য আছে।

পুরো যুদ্ধের মধ্যে প্রতিটি খেলোয়াড়ের 64৪ টি অক্ষরের স্ট্রিং থাকে যা তারা প্রতিটি স্ট্রাক চলাকালীন ডেটা সঞ্চয় করতে এবং তাদের সতীর্থদের সাথে সম্ভাব্য যোগাযোগ করার জন্য ম্যানিপুলেট করতে পারে। প্রতিটি খেলোয়াড়ের স্ট্রিং খালি স্ট্রিং হিসাবে শুরু হয়। যখন কোনও খেলোয়াড় যুদ্ধ থেকে সরানো হয়, তাদের স্ট্রিংটি "এক্স" তে সেট করা থাকে।

  • setMsg একটি আর্গুমেন্ট ফাংশন যা আপনার স্ট্রিংটি স্ট্রিংয়ে প্রবেশ করে।
    • যদি পাস করা মানটি কোনও স্ট্রিং না হয় তবে আপনার স্ট্রিংটি পরিবর্তন হয় না।
    • মানটি যদি 64 টিরও বেশি অক্ষরের স্ট্রিং থাকে তবে কেবল প্রথম 64 টি রাখা হয়।
  • getMsg এটি একটি যুক্তি ফাংশন যা আপনার দলের কোনও ব্যক্তির পিপিসিজি ব্যবহারকারী আইডি নম্বর (পূর্ণসংখ্যা হিসাবে) নেয় এবং তার স্ট্রিংটি ফেরত দেয়।
    • সেই প্লেয়ার গ্রিডের যে কোনও জায়গায় থাকতে পারে। এগুলি আপনার 16 পিক্সেলের ব্যাসার্ধে থাকার দরকার নেই।
    • undefined প্রদত্ত আইডি না পাওয়া গেলে ফেরত দেওয়া হয়।

উদাহরণ জমা দেওয়া

এই খেলোয়াড় বামদিকে শত্রু থাকলে উপরে এবং ডানে সরে যায়, অথবা আইডি 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 ঘন্টা চিহ্ন বা এরকম কিছু পরে আপনার পোস্ট সম্পাদনা করে তবে আমি এটি দেব just

    আপনি যদি আপনার পোস্ট মুছে ফেলেন এবং এটি মুছে ফেলার জন্য চয়ন করেন তবে সম্পাদনার নিয়ম এখনও প্রযোজ্য। (নিয়ামক মুছে ফেলা উত্তরগুলি দেখতে পারে না))

  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- এ শেষ হবে day এদিন (রাত 11 টা ইউটিসি) আমি কমপক্ষে 100 টি যুদ্ধ (স্বতঃস্ফূর্তভাবে কতটা বেশি সময় নেয় তার উপর নির্ভর করে আরও অনেকগুলি) অটোরিয়ন করব। যে দলটি সবচেয়ে বেশি বিজয়ী হবে তারা সামগ্রিক বিজয়ী হবে। এটি যদি টাই বা চূড়ান্ত কাছাকাছি হয় তবে একটি দলের সুবিধা আছে তা স্পষ্ট না হওয়া পর্যন্ত আমি আরও লড়াই করব।

(বিজয়ীর সিদ্ধান্ত নেওয়ার পরে আপনি উত্তর দিতে পারেন, তবে আমি অফিসিয়াল ফলাফল পরিবর্তন করব না))

আমি এগুলিকে উইন্ডোজ 8.1 64-বিট, 4 জিবি র‌্যাম এবং একটি 1.6GHz কোয়াড কোর প্রসেসর সহ ল্যাপটপে গুগল ক্রোমের সর্বশেষ সংস্করণে চালাচ্ছি। আপনার জাভাস্ক্রিপ্ট ক্রোমে কাজ করে তা নিশ্চিত করুন।

বিজয়টি মূলত দলের গৌরব সম্পর্কে, তবে আমি বিজয়ী দলের পক্ষে সর্বাধিক ভোট প্রাপ্ত উত্তরটি গ্রহণ করব।

প্রতিযোগিতা জুড়ে, মনে রাখবেন যে টিম ভিত্তিক দিক এবং এটি পুরোপুরি স্ট্যাক স্নিপেটে চালিত হয়েছে, এটি অত্যন্ত পরীক্ষামূলক। আমার উচ্চ আশা আছে, তবে জিনিসগুলি কীভাবে কার্যকর হবে তা নিশ্চিত করে বলতে পারি না।

পরামর্শ:

  • উত্তর দেওয়ার আগে আপনি এন্ট্রি পরীক্ষা করতে পারেন। স্ট্যাক স্নিপেটের নীচে "টেস্ট এন্ট্রি" পাঠ্যবক্সটি সম্পাদনা করুন এবং "পরীক্ষার এন্ট্রি সহ পুনরায় লোড করুন" এ ক্লিক করুন। এটি খালি না হলে এটি নির্দিষ্ট দলের খেলোয়াড় হয়ে যায়।
  • উত্তরগুলি একটি মুখোশযুক্ত সুযোগে চালানো হয়, সুতরাং জিনিসগুলি পছন্দ করে alertএবং console.logকাজ করে না। consoleবস্তুটি কেবল পরীক্ষার প্রবেশে ব্যবহার করা যেতে পারে।
  • স্ট্যাক স্নিপেটের নীচে "ডিবাগ বার্তাগুলি" চেক করুন এবং আপনার ব্রাউজারের কনসোলটি দেখুন (F12)। যুদ্ধ চলাকালীন প্রচুর দরকারী তথ্য মুদ্রিত হয়।
  • আপনি এক ধরণের মঞ্চ অঞ্চল হিসাবে মেটা স্যান্ডবক্স পোস্টটি ব্যবহার করতে পারেন । উত্তরগুলি এখানে অবশ্যই অবশ্যই আলাদা এবং সেখানকার নিয়ামক পুরানো হয়ে যেতে পারে।
  • যেহেতু এটি কোনও অফিশিয়াল স্ট্যাক অ্যাপ নয় , আপনি যদি দিনে দিনে 300 বারের বেশি পুনরায় চালু করেন তবে নিয়ামক আপনার জন্য উত্তরগুলি লোড করা বন্ধ করতে পারে।

এই চ্যালেঞ্জের "সিক্যুয়েল": ব্লক বিল্ডিং বট ফ্লক্স!

দ্রুত লিঙ্ক

ফিডল কন্ট্রোলার    ফুলস্ক্রিন    সাধারণ চ্যাট    রেড চ্যাট    (নীল চ্যাট?)    স্যান্ডবক্সপোস্ট ost


51
এগুলি একসাথে রেখে আপনি একটি দুর্দান্ত কাজ করেছিলেন।
অ্যালেক্স এ।

6
প্রত্যেকে, অ-গুরুত্বপূর্ণ মন্তব্যগুলির জন্য চ্যাটটি ব্যবহার করুন।
ক্যালভিনের শখ

4
লাল দল এই চ্যাট-রুমে সমন্বয় করছে: chat.stackexchange.com/rooms/22548/…
অ্যাডাম ডেভিস

5
আমাকে সাহায্য করুন, আমি একেবারে প্রেমে আছি আপনার পরিচিত প্রতিটি একক বিকাশকারীকে দয়া করে শব্দটি ছড়িয়ে দিন।
হিলিয়ানপফবল

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 এর বোটের সাথে একটি জুটি তৈরি করে ।

মূল ধারণাটি হ'ল দুটি বট, একে অপরের সাথে সংযুক্ত, একে অপরের দুর্বলতাগুলি coverাকতে সহায়তা করে, যাতে বটের উভয়ই একটি উন্মুক্ত দিক না রাখে। এটি হুমকী থেকে রক্ষা করতে এবং লক্ষ্যটির পালানোর বিকল্পগুলিকে সীমাবদ্ধ করতে সহায়তা করে।

গেমের শুরুতে তারা একে অপরের দিকে চলাচল করে এবং একটি জুটি তৈরি করে। এই জোড়াটি তখন একক ইউনিট হিসাবে চলে যায়, একটি বট অন্যটি নেতৃত্ব দেয়। দুটি বটগুলির প্রায় অভিন্ন কোড রয়েছে, তাদের প্রয়োজনীয় অবস্থানের এবং অবস্থানের ভূমিকা পালন করে।

নিষ্ক্রিয় হয়ে গেলে, বটগুলি শত্রুদের সন্ধানে বোর্ডের চারদিকে ঘোরে। একবার তারা কোনও শত্রুকে চিহ্নিত করার পরে তারা সতর্কতার সাথে আক্রমণ করার সঠিক অবস্থানগুলিতে চালনা করে। খুব পরিষ্কার পরিচ্ছন্ন বৈশিষ্ট্যটি হ'ল সরু অনুভূমিকভাবে সরানোর গঠনের ক্ষমতা, বটগুলি বিকল্প জায়গাগুলির দ্বারা অর্জন করা।


9
ওহে প্রিয়! তারা জুড়ি গঠনের সাথে সাথেই এটি লাল রঙের জন্য একটি স্বয়ংক্রিয় ক্ষতি।
মিনোস

@ মিনোস প্রেটি অনেক, হ্যাঁ :)
আয়নালিগুস্তি

আমি লাল রঙের জন্য অনুরূপ বট লেখার কথা ভেবেছিলাম তবে এর আগে ঘেঁষতে পারি নি, এখন আমাকে এমন কৌশল নিয়ে আসতে হবে যা দুজনকে পরাজিত করতে পারে।
নিট

রেকর্ডের জন্য, আমি দেখেছি যে এমন একটি জায়গা রয়েছে যেখানে varএই পোস্ট এবং এসপি 3000-এ ব্যবহৃত হয় না। তারা 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;
    }
}

এই বটটি ফিলনটপি-র বটের সাথে একটি জুটি তৈরি করে । আমাদের কৌশলটির সংক্ষিপ্ত ব্যাখ্যার জন্য ফি এর পোস্ট দেখুন।


সেকি! ভাল এক ..
ডাবলডুবল

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;

সিকারবোটের সর্বোচ্চ অগ্রাধিকার হ'ল বেঁচে থাকা। অতএব, এটি কেবল সেই পদক্ষেপগুলি বিবেচনা করবে যা এটি পরের বারে মারা যাওয়ার ঝুঁকিতে ফেলবে না (যতক্ষণ না এই ধরণের পদক্ষেপ বিদ্যমান)।

যখন কোনও বিরোধী দৃষ্টিতে না থাকে, তখন এটি যুদ্ধক্ষেত্রের উপরের ধরণে চলে যাবে, যা নিশ্চিত করবে যে বেশিরভাগ স্থল নিয়মিত দূরত্বকে দেখবে।

যদি সিকারবট কোনও শত্রুকে দাগ দেয় তবে এটি তার দিকে এগিয়ে যাবে। যদি এটি কোনও শত্রুকে হত্যা করতে পারে তবে যতক্ষণ না চালানো যায় ততক্ষণ তা তা করবে do

যদি এটি কোনও শত্রুকে হত্যা করতে না পারে তবে শত্রু এটির পরবর্তী সময়ে তাকে হত্যা করতে পারে তবে সিকারবট শত্রুকে বন্ধুর প্রতি আকৃষ্ট করার চেষ্টা করবে (যদি সে দৃশ্যমান থাকে)। কোনও দলের সদস্য যদি না দেখেন তবে এটি এমন অবস্থানে চলে যাওয়ার চেষ্টা করবে, যেখানে পরের পালাটি শত্রুকে হত্যা করতে পারে। এটি যদি একটানা 5 বার কাজ না করে, তবে কৌশলগুলি পরিবর্তন করে এবং এলোমেলো প্যাটার্নে চলতে শুরু করবে, সম্ভবত পরবর্তী রাউন্ডে আবার শত্রুতে প্রবেশ করবে।

এটির মূল্যের জন্য, এটি "x; y" ফর্ম্যাটটিতে (যেখানে x এবং y শূন্য প্যাডযুক্ত) ফর্ম্যাটটিতে নিজের অবস্থানটি চিৎকার করতে বার্তার প্রথম 7 টি অক্ষর ব্যবহার করবে।

এটি অবশ্যই সবচেয়ে পরিষ্কার কোড নয়, তবে এটির থেকে আমি যা প্রত্যাশা করেছি তা এটি মনে হয়।



2
প্রতিবার যখন আমি এটি চালিয়েছি তখন আপনি লাল দলকে জিতিয়ে নিয়ে এসেছেন। দুটি নতুন নীল বট একবার গ্যাং আপ করার পরে তা কী তা দেখতে আকর্ষণীয় হবে।
অ্যাডাম ডেভিস

এই
বধটি

@ অ্যাডামডাভিস এই দুটি নীল বট সমন্বয় করা উন্মাদ; আমি এখনও অবধি প্রতিটি খেলা দেখেছি তারা ছিটকে গেছে!
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(মূলধন ঝ) পরিবর্তে। বা 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% বেসিক নয়।

এটি কেবল যদি প্রয়োজন হয় তবে সরানো হয় ।

একটি ব্যবহারকারী মধ্যে 2 নম্বর সহ একটি বার্তা পাঠালে -1এবং 1(যেমন: '1,0'), একটি কমা দিয়ে পৃথক করা, সেখানে এটা সরে যাবে। এটি সম্পূর্ণরূপে তার সতীর্থদের উপর বিশ্বাস করে।

এটি এখন জেএসএন-তে যোগাযোগ করে। এটির একটি খুব প্রাথমিক কাঠামো রয়েছে:

  • getMsg:
    • একটি: কর্ম নির্ধারণ করে:
      • 0: থামুন
      • 1: সরান
    • মি: পাঠানোর আন্দোলন
      • {x: n, y: n}: x এবং y দিয়ে অবজেক্ট, -1 এবং 1 এর মধ্যে
      • গ্রিডে প্রতিনিধিত্ব করা সংখ্যার সাথে প্রত্যাবর্তনের কাঁচা মান।
  • setMsg:
    • একটি: নির্দেশিত করে যদি এটি সরানো হয় বা এটি বন্ধ হয়ে যায়;
    • ও: আমার পুরানো অবস্থানের সাথে একটি অ্যারে;
    • এম: কাঁচা আন্দোলন কোড দ্বারা ফিরে;
    • আইডি: যদি কোনও আদেশকে সম্মান জানানো হয় তবে এতে দোষীদের আইডি থাকবে;
    • e: সমস্ত শত্রু অবস্থানের সাথে তালিকাবদ্ধ করুন। প্রিন্টযোগ্য অক্ষরগুলি এড়ানোর জন্য প্রতিটি অবস্থান 32 দ্বারা পক্ষপাতযুক্ত। শত্রুর অবস্থান পেতে স্ট্রিং.কোর্ডএড (আই) -32 ব্যবহার করুন। এটি এমনকি দৈর্ঘ্যের একটি স্ট্রিং হবে। প্রতিটি শত্রু 2 অক্ষর হবে।

এটি নিয়ন্ত্রণ করার জন্য একটি বার্তার উদাহরণ:

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

যা প্রেরণ করবে:

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

তিনিও কিছুটা স্বার্থপর এবং আপনাকে সাহায্য করবে না এবং এখন তিনি স্টেশনারি বীকন হিসাবে সহায়ক।

যদি এই বার্তাটি ভুল হয় (ফর্ম্যাটটি সঠিক নয়) তবে এর "}পরিবর্তে যুক্ত করার চেষ্টা করুন }


এটি সম্পাদনা 6 ঘন্টা সীমা পরে এবং এটি 8 এ প্রসারিত করার পরে হয়েছিল।

এটি আর ভাঙ্গা নেই এবং এটি চূড়ান্ত সংস্করণ হিসাবে থাকবে।


2
লাল দলের একজন হিসাবে, আমি মনে করি যে আমাদের অন্তর্ভুক্ত করা উচিত এমন একটি গুরুত্বপূর্ণ বিষয় হ'ল সর্বদা আপনার বর্তমান পরিস্থিতি এবং একটি বস্তুর কিছু স্বীকৃত আকারে একটি বার্তা স্থাপন করা উচিত ( এটিতে কী সেট করা হয়েছিল তা অন্তর্ভুক্ত থাকতে হবে , অন্যথায় বট জিতেছে ' কোন রাষ্ট্রটি পুরানো তা জানেন না)। এটি অন্যান্য, পরবর্তী বটগুলি তাদের নিজস্ব আশেপাশের, সম্ভবত পুরো বোর্ডের চেয়ে বেশি সচেতন হতে এবং আরও ভাল সিদ্ধান্ত নেওয়ার অনুমতি দেবে।
নিত

@ না আমি আপনার সাথে একমত নই এবং এই কারণেই আমি যোগাযোগ করতে JSON ব্যবহার করার জন্য এই পছন্দটি করেছি। আমার কাছে পরিবর্তন করতে 5 ঘন্টা 22 ঘন্টা রয়েছে have আর কোন ধারণা?
ইসমাইল মিগুয়েল

1
আমি ভাবছি প্রথম কয়েকটি স্ক্যানার হওয়া দরকার। পুরো বোর্ডকে আঁকতে আমাদের কেবল চারপাশে ঝাড়ফুঁক করতে হবে (32 টি কার্যকর স্ক্যানিং প্রস্থ বোর্ডের 1/4 অংশ কভার করে)। পাশাপাশি চলে যান, বাইনারি বা সংক্রামিত স্ট্রিং ব্যবহার করে নিকটতম এন খারাপ ছেলেগুলিকে সেটসম্জ করুন, বা হয় খারাপ ছেলেরা এড়িয়ে চলুন, বা হত্যা করা এড়াতে যুক্তিসঙ্গত কৌশল ব্যবহার করে খারাপ ছেলেদের সন্ধান করুন এবং হত্যা করুন (এগুলি কখনই আপনার কোণে উঠতে দেবেন না এবং উপরে বা নীচেও) আপনি?).
অ্যাডাম ডেভিস

1
@ ইসমাইল মিগুয়েল নাপ আমি শীঘ্রই একটি জমা দেওয়ার প্রত্যাশা করছি, তবে জাভাস্ক্রিপ্ট না জেনে আমার মন্থর হচ্ছে।
অ্যাডাম ডেভিস

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);
        }
    }
}

এই বটটি যতটা সম্ভব সনাক্ত করা এড়াতে স্থির থাকে। যখন এক বা একাধিক শত্রু দৃষ্টিতে থাকে, তখন বেশ কয়েকটি জিনিস ঘটতে পারে:

  • যদি বোট এবং তার সহযোগীদের চেয়ে বেশি শত্রু থাকে তবে সে নিকটতম শত্রু থেকে দূরে সরে যাওয়ার চেষ্টা করে।
  • শত্রুদের তুলনায় আরও বন্ধুবান্ধব থাকলে, সংখ্যাগরিষ্ঠতা বটকে সাহস দেয় এবং শত্রুকে এগিয়ে যাওয়ার চেষ্টা করে।
  • তিনি যদি তার পাশের কোনও শত্রুকে হত্যা করতে পারেন তবে সে যতই বন্ধুত্বপূর্ণ এবং শত্রু বট থাকুক না কেন, সর্বদা চেষ্টা করবে এমন একটি কোষে শেষ করার চেষ্টা করবে যাতে অন্য বোট দ্বারা আক্রমণ করা যায় না।
  • সমস্ত শত্রুরা অন্য শত্রু দ্বারা সুরক্ষিত থাকলে পালানোর চেষ্টা করে।
  • তিনি যদি কোথাও যেতে না পারেন কারণ সমস্ত অবস্থানগুলিতে আক্রমণ করা যেতে পারে, কামিকজে মোডে প্রবেশ করে এবং তাকে অন্তত কাউকে কবরে নিয়ে যাওয়ার চেষ্টা করেন।

কারও সাথে যোগাযোগ করে না, যদি কেউ তাকে শুনতে এবং তার পিছনে যেতে পারে।

এটি দলের পক্ষে সবচেয়ে দরকারী বট নাও হতে পারে, তবে তাকে সবার থেকে দূরে সরে যাওয়ার চেষ্টা করতে দেখে মজা পেয়েছিল।


ঠিক আছে, আমি তোমার বট পছন্দ করি। আমার বিপরীতমুখী (এটি শত্রুদের সন্ধান করে এবং তারপর কেন্দ্রে চলে যায়), তাই তাদের মধ্যে একটি দুর্দান্ত মিথস্ক্রিয়া রয়েছে যেখানে আমার আপনাকে কোণ থেকে বের করে এনে মাঝখানে টেনে আনার চেষ্টা করতে পারে তবে আপনার যদি কেউ কাউকে দেখেন তবে এটি ভয় পেয়ে যায় they এবং এটি আবার কোণে চলে যায়, যখন আমার তা তাড়া করে।
হিলিয়ানপুবলবল

ধন্যবাদ! তাকে অন্যের সাথে ইন্টারঅ্যাক্ট করতে দেখে আমি মজা পেয়েছি। তবে আমি সীমানা এবং এটি কীভাবে বাউন্স করে সে সম্পর্কে কয়েকটি বাগ খুঁজে পেয়েছি, তবে সেগুলি ঠিক করতে খুব দেরি হয়েছে ... সুতরাং আমি এটির মতো পছন্দ করি না।
rorlork

9

নীল দল - agগল

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
@ জাকুব বা (Math.random() * 6) & 6বা (Math.random() * 6) << 0বা (Math.random() * 6) >> 0 (কোডগল্ফের জন্য দরকারী)।
ইসমাইল মিগুয়েল

তোমার কি দরকার নেই Math.random() * 7? আমি কয়েকটি পরীক্ষার রান চেষ্টা করেছি এবং মনে হচ্ছে আপনার বটটি নীচে ডানদিকে যাবে না। আইআইআরসি 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

নীল দল - অলস সৈনিক

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 স্ট্রিংকে নিকটবর্তী eminems অবস্থানের অন্তর্ভুক্ত
Dieter

আমি এখনই ফর্ম্যাটটি পরিবর্তন করছি
ডাইটার

1
আপনার এটি JSON.parseচেষ্টা / ক্যাচ ব্লক বা অন্য কোনও কিছুতে রাখা দরকার ... এটি অনেকগুলি ত্রুটি ঘটায়।
12

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]

  • অলস স্লেয়ারের জেএসএন ফর্ম্যাটটি ব্যবহার করে মিত্রদের শত্রুদের অবস্থানগুলি পড়ে "e":"[positions]"; [positions]উভয় দ্বারা অফসেট গ্রহণ করে 32এবং174

  • অলস স্লেয়ারের জেএসএন ফর্ম্যাটে শত্রু অবস্থানগুলি প্রতিবেদন করে, "e":"[positions]"অফসেট করে174

  • "m":[move]এই বটটি আদেশ করা যেতে পারে তা বোঝাতে সর্বশেষে সরানো প্রতিবেদনগুলি

  • অন্যান্য বট ব্যবহার করে কমান্ড জারি করে "[ally_id]":{"m":[move],"a":1,"id":29354}। কমান্ড সহযোগীর অবস্থান ব্যতীত একই সন্ধানকারী অ্যালগরিদম ব্যবহার করে। অন্যান্য বটগুলি যদি এই আদেশগুলি শোনেন তবে তাদের একত্রিত হয়ে একটি প্যাকের মধ্যে শিকার করা উচিত in মিত্রের বার্তায় অন্তর্ভুক্ত থাকলে কেবল অর্ডার দেওয়া হয়"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

নীল দল - [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;

[সম্পাদনা: দেখা যাচ্ছে যখন আমি আমার আসল আইডি ব্যবহার করি এবং না -১!

বোর্ডের চারদিকে চালিত একটি বোবা ছোট্ট বট, মনোযোগ আকর্ষণ করার জন্য এবং চেজারগুলি আঁকার জন্য যথাসাধ্য চেষ্টা করে এবং তারপরে মাঝখানে ছুটে যায় যেখানে (আশা করা যায়) তাকে সাহায্য করার জন্য কাউকে খুঁজে পাবেন, বা তিনি কেবল চেজারটি স্টল করে তাকে থামিয়ে দেবেন শিকার থেকে।

নীল ট্যাগটামটি কতটা শক্তিশালী বলে সামগ্রিক স্কোরটিতে বিশাল প্রভাব ফেলবে বলে মনে হয় না, তবে খুব কমপক্ষে আমি জিনিসগুলিকে আরও খারাপ করে ফেলিনি!

আপনি যদি আমার বার্তায় দরকারী কিছু যুক্ত করতে চান তবে পরবর্তী আট ঘন্টা ধরে চিৎকার করুন।


মাঝখানে দৃষ্টি আকর্ষণ করার সেরা জায়গা নয়; শত্রুদের লড়াইয়ের জন্য খুঁজলে অন্যান্য অনেক বটগুলি প্রান্তটি বৃত্তাকার বলে মনে হয়। আপনার বট মাঝখানে বৃত্তাকার উচিত?
theonlygusti

কোণার চেয়ে মাঝখানে এড়ানো সহজ but তবে আপনি যদি বলছেন যে আমি মাঝখানে সতীর্থকে খুঁজে পাব না ... ভাল, আপনি ঠিক বলেছেন; আমার এই মুহুর্তে মৃত্যুর 1 কারণ হ'ল লাল করার আগে আমার একটি মিত্র হয়। পরবর্তী কোটএইচের জন্য, আমি যখন কোনও টার্গেট পেয়েছি তখন সাহায্যের জন্য অন্যান্য বটগুলি কল করার ক্ষমতাটি উন্নত করতে আমি প্রস্তুত!
হিলিয়ানপফবল

আমি বেকন নামে একটি বোটে কাজ করছি; এটির প্রতিযোগিতায় মাঠে প্রতিটি শত্রু এবং দলের সদস্যের অবস্থান থাকবে, এবং এরপরে অন্যান্য বট দ্বারা কথিত শত্রুদের ট্র্যাক করতে ও হত্যা করতে সক্ষম হতে পারে, বা সতীর্থ থাকলে ল্যাচ করতে পারে।
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);
}

কোডটি স্ব-ডকুমেন্টিংয়ের মতো। পেট্রোলবোট উন্নত করার জন্য যে জিনিসগুলি করা যেতে পারে

  • রিফ্যাক্টর - সবকিছু আইআইএফই-তে স্থানান্তরিত করুন, বিশটি ম্যাজিলিয়ন বার পাস করার পরিবর্তে বন্ধ থেকে ভেরিয়েবলগুলি ব্যবহার করুন।
  • if (canBeKilled() || isInWall()) { moveToBetterPosition() }ফিরে আসার ঠিক আগে যুক্ত করুন ।
  • কোনও প্রাচীরের পাশে দলের সদস্যকে অনুসরণ করার সময় খারাপ আচরণ পরিষ্কার করুন Clean
  • দলের সদস্যদের অবতরণ এড়ান।
  • অবিচ্ছিন্নভাবে 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]]]এবং আরও শত্রুদের জন্য on


1

নীল দল - ভার্সাবট, একটি পলিমারফিক ইঞ্জিন

আমার কোড স্বয়ংক্রিয়ভাবে এর নিকটতম নিকটতম বট অনুসরণ করবে, অতিরিক্ত ফায়ারপাওয়ার এবং সুরক্ষা সরবরাহ করবে।

// 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);
}

উপভোগ করুন!

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.