প্রতিযোগিতা শেষ! তাদের স্কোর দেখতে ব্লবগুলিতে মন্তব্য পড়ুন।

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

শক্তি এবং আন্দোলন

আপনার ব্লবটি প্রতিটি জ্বালানী 100 টি শক্তি দিয়ে শুরু হয় এবং এটি কী পরিমাণ শক্তি সংগ্রহ করতে পারে তার কোনও সীমা নেই। প্রতিটি রাউন্ড ঘুরে ফিরে চালানো হয়, প্রতিটি ব্লবকে উত্তর, পূর্ব, দক্ষিণ বা পশ্চিমকে যে কোনও ঘুরিয়ে নিয়ে যাওয়ার বা স্থির হয়ে দাঁড়ানোর বিকল্প রয়েছে। চলন্ত 1 টি শক্তি ব্যবহার করে এবং স্থির স্থানে এখনও 0.25 শক্তি ব্যবহার করে। মানচিত্রের পাশের দৈর্ঘ্যceil(0.25 * blobCount) * 2 - 1সর্বনিম্ন 9 ইউনিট সহ ইউনিট। সমস্ত ব্লবগুলি মানচিত্রের প্রান্তে শুরু হয়, প্রতিটি কোণায় একটি করে এবং পরবর্তী ব্লবটি অন্য কোনও থেকে 2 ইউনিট দূরে স্থাপন করা হয়। প্রতি 30 টার্নে, ছোঁড়ার একটি তরঙ্গ মানচিত্রের চারপাশে এলোমেলো দাগে স্থাপন করা হয়, কোনও প্রান্ত থেকে কমপক্ষে 1 ইউনিট। প্রতিবার যখন একটি ছোট ছোট তরঙ্গ প্রদর্শিত হয়, পরের তরঙ্গের মধ্যে গুলিগুলির পরিমাণ (মূলত ব্লবের সংখ্যা বা মানচিত্রের প্রস্থের দ্বিগুণ, যা আরও বড় হয়) 1 দ্বারা হ্রাস পেয়েছে, সময়ের সাথে সাথে ব্লবের সংখ্যা হ্রাস করতে বাধ্য করে। প্রতিটি পেললেট 5 থেকে 15 শক্তির মধ্যে পুনরুদ্ধার করে। যখন কোনও ব্লকের শক্তি 0 এর চেয়ে কম বা সমান হয়, তখন এটি মারা যায়।

আহার

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

সনাক্তকরণ এবং তথ্য

4 টি ইউনিটের দূরত্বের মধ্যে ব্লবগুলি যে কোনও পেললেট বা অন্যান্য ব্লব দেখতে পাবে। যখন তাদের ফাংশনগুলি বলা হয়, ব্লবগুলি সরবরাহ করা হয়:

মানচিত্রের পাশের দৈর্ঘ্য
মানচিত্রে অঙ্কুরের অবস্থান
তাদের অনুসন্ধান ব্যাসার্ধের মধ্যে থাকা সমস্ত গুলির অবস্থান, পাশাপাশি তাদের মান
তাদের অনুসন্ধান ব্যাসার্ধের মধ্যে সমস্ত ব্লবগুলির অবস্থান পাশাপাশি তাদের শক্তি এবং ইউআইডি
যার কার্য সম্পাদন করা হচ্ছে সেই ব্লবের শক্তি, ইউআইডি এবং অবস্থানগুলি
একটি স্টোরেজ অবজেক্ট ব্লব থেকে অনন্য
বিভাজনের মাধ্যমে ব্লব সম্পর্কিত সমস্ত ব্লব দ্বারা ভাগ করা একটি স্টোরেজ অবজেক্ট

বিদারক

যদি একটি ফোটাতে 50 টিরও বেশি শক্তি থাকে তবে এটি বিভাজন চয়ন করতে পারে। বিভক্তকরণের জন্য 50 শক্তি ব্যয় হয় এবং অন্য যে কোনও শক্তি দু'টি ব্লকের মধ্যে সমানভাবে বিভক্ত হয়। সমস্ত ব্লব হয় মূল বা বিভক্ত অনুলিপি, প্রতিটি অনুলিপি একটি আসল ফিরে। এই সব একসাথে "আত্মীয়"। সমস্ত আত্মীয়ের একটি সাম্প্রদায়িক স্টোরেজ অবজেক্ট রয়েছে। স্বজনরা এখনও একে অপরকে খেতে পারেন এবং ভাগ করতে পারেন, তাদের নিজস্ব স্টোরেজ অবজেক্ট ব্যবহার করতে পারেন বা অন্যকে প্রভাবিত না করে শক্তি সংগ্রহ করতে পারেন।

শক্তি স্থানান্তর

যদি দুটি ব্লব একে অপরের পাশে থাকে (সরানোর পরে), তবে একটি বট অন্যর মধ্যে শক্তি স্থানান্তর করতে পারে। এই ফিরে সম্পন্ন করা হয় SendNorth(amt), SendEast(amt), SendSouth(amt), অথবা SendWest(amt), সঙ্গে amtহচ্ছে একটি সংখ্যা পরিমাণ প্রতিনিধিত্বমূলক পাঠিয়ে দিলেন। এটি প্রেরক তাদের সমস্ত শক্তি সহ মোটামুটি যে পরিমাণ অর্থ ব্যয় করতে পারে be সুপারিশ করা হয় যে শক্তিটি প্রাপ্ত ব্লবকে সাম্প্রদায়িক স্টোরেজের মাধ্যমে স্থির থাকতে বলা হয়েছে, যাতে শক্তি স্থানান্তরিত হওয়ার সময় এটি সরে না যায় (যদিও এই ক্ষেত্রে প্রেরকের মোট থেকে শক্তি কেটে নেওয়া হবে না)।

ফাংশন, স্টোরেজ এবং ইউআইডি

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

পূর্ণসংখ্যা হিসাবে মানচিত্রের পাশের দৈর্ঘ্য
দুটি অ্যারে সহ একটি বস্তু: pelletsএবং blobs। উভয় অ্যারেতে অবজেক্ট থাকে, উভয়ই একটি posসম্পত্তি যার মধ্যে পেল্ট থাকে বা ব্লাবের অবস্থান ফর্ম্যাট থাকে [x,y]। শিলাগুলির একটি energyসম্পত্তি থাকবে এবং ব্লবগুলির একটি uidসম্পত্তি এবং energyসম্পত্তি থাকবে
ফোঁটা বিভিন্ন বৈশিষ্ট্য সম্পর্কে একটি বস্তুর এটা পাস হয়: energy, uid, এবং pos। posঅ্যারে হিসাবে ফরম্যাট করা[x,y]
ব্লবের দুটি স্টোরেজ অবজেক্ট যুক্ত একটি বস্তু। একটি selfসম্পত্তিতে একটি পৃথক স্টোরেজ অবজেক্ট থাকে যা সংক্ষিপ্ত হতে পারে তবে ব্লবটি উপযুক্ত দেখায় (পাশ করা বস্তুর বৈশিষ্ট্যগুলি ম্যানিপুলেট করে) এবং কোনও communalসম্পত্তি যা কোনও আত্মীয় দ্বারা সংশোধন করা যায়।

প্রথম দিকে / পরে পরিবর্তিত হওয়ার ফলে কোনও সুবিধা হওয়ার সাথে সাথে ব্লবগুলি অবিলম্বে সরানো হয় না are সমস্ত আন্দোলন গোষ্ঠীগুলিতে প্রক্রিয়াজাত করা হয় (সমস্ত সংঘর্ষ / খাওয়া, তারপরে সমস্ত গুলী, তারপরে বিভাজন ইত্যাদি) যদি কোনও ফোটা একটি গুলি বা ছোট ফোটাতে অবতরণ করে এবং প্রক্রিয়াটিতে তার শেষ শক্তি ব্যবহার করে, ব্লবটি তখনও গুলিটি গ্রাস করবে / যে তার সম্পূর্ণ শক্তি 0 এর উপরে আনবে কিনা তা থেকে স্বাধীন শক্তি।

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

রিটার্ন মান

সরানো বা বিভক্ত করার জন্য, ফাংশনের রিটার্ন মান ব্যবহার করা হয়। প্রথমে স্থানাঙ্কের দিক থেকে মূল দিকনির্দেশগুলির অর্থ:

উত্তর = -ওয়াই
পূর্ব = + এক্স
দক্ষিণ = + ওয়াই
পশ্চিম = এক্স

নোটটি [0,0]এটি শীর্ষে বাম কোণে এবং আপনি নিচে যেতে যেতে Y বৃদ্ধি পাবে। ফাংশনের রিটার্ন মানটি এই নিয়মগুলি অনুসরণ করা উচিত:

কিছুই করার নেই: 0, নাল, অপরিজ্ঞাত, মিথ্যা বা অন্য কোনও মান যা মিথ্যের সাথে সমান হয় তা ফেরত পাঠান না
সরানোর জন্য: চারটি বৈশ্বিক ভেরিয়েবলের মধ্যে একটি ফেরান: উত্তর, পূর্ব, দক্ষিণ বা পশ্চিম, যা "উত্তর", "পূর্ব", "দক্ষিণ" বা "পশ্চিম" এর সমান হয় (যা ফেরতের মান হিসাবেও ব্যবহৃত হতে পারে)
বিভক্ত করতে: গ্লোবাল ভেরিয়েবল স্প্লিটনার্থ, স্প্লিটএস্ট, স্প্লিটসথ বা স্প্লিটওয়েস্ট ফিরিয়ে দিন, নতুন ব্লবটি কোথায় রাখবেন তা নির্দেশ করে direction

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

পূর্বনির্ধারিত গ্রন্থাগার ফাংশন

কিছু সময় সাশ্রয় করার জন্য ডিফল্টরূপে কয়েকটি বেসিক ফাংশন রয়েছে:

ট্যাক্সিডিস্ট (পিটি 1, পিটি 2)

দুটি পয়েন্টের মধ্যে ট্যাক্সিক্যাব দূরত্ব (এক্স দূরত্ব প্লাস ওয়াই দূরত্ব) প্রদান করে।

taxiDist([0, 0], [2, 2]) //4
taxiDist([3, 4], [1, 5]) //3
taxiDist([1.25, 1.3], [1.3, 1.4]) //0.15
taxiDist([0, 0], [5, 2.5], 2.5) //3
taxiDist([0, 0], [2, 4], 2.5) //2.4

হাইপোডিস্ট (পিটি 1, পিটি 2)

পাইথাগোরিয়ান উপপাদ্য অনুসারে দুটি পয়েন্টের মধ্যে দূরত্ব ফিরে আসে

hypotDist([0, 0], [5, 12]) //13
hypotDist([4, 6], [8, 9]) //5
hypotDist([0, 1], [2, 1]) //2
hypotDist([1, 1], [2, 2]) //sqrt(2)

modDir (dir, amt)

ইনপুটড দিকটি নেয়, 90 ডিগ্রি ঘড়ির কাঁটার amtসময় ঘোরায় , তারপরে নতুন মানটি দেয়।

modDist(North, 1) //East
modDist(East, 2) //West
modDist(West, 3) //South
modDist(South, 4) //South

উদাহরণ ব্লব

যতক্ষণ না কাছাকাছি একটি পেলিট খুঁজে পাওয়া যায় ততক্ষণ এই ব্লকটি সরবে না। তারপরে, এটি যে দিকে অগ্রসর হবে বলে মনে করে সে দিকে চলে যাবে। এর শক্তি যদি কখনও 150 এর উপরে হয় তবে এটি বিভক্ত হবে।

function(map, near, me, storage) {
    if (me.energy > 150)
        return SplitNorth;
    if (!near.pellets.length)
        return null;
    var dirs = [0, 0, 0, 0];
    for (let p, i = 0; i < near.pellets.length; i++) {
        p = near.pellets[i];
        dirs[0] += me.pos[1] - p.pos[1];
        dirs[1] += p.pos[0] - me.pos[0];
        dirs[2] += p.pos[1] - me.pos[1];
        dirs[3] += me.pos[0] - p.pos[0];
    }
    return [North, East, South, West][dirs.indexOf(Math.max(...dirs))];
}

বিধি

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

নিয়ামক: https://gist.github.com/RedwolfProgram/1facc0afe24c5dfd3ada8b8a2c493242

চ্যাটরুম: https://chat.stackexchange.com/rooms/93370/hungry-blobs-koth

king-of-the-hill

— রেডওয়ালফ প্রোগ্রামসমূহ
সূত্র

1

আপনি এটি জাভাস্ক্রিপ্ট ছাড়াও অন্যান্য ভাষায় প্রসারিত করতে পারেন?

— অজ্ঞতার

@ এম্বোডিমেন্টফ অজানা আপনি যে কোনও ভাষা চয়ন করুন এটি জমা দিন এবং আমি জেএসতে রূপান্তর করব।

— রেডউল্ফ প্রোগ্রামগুলি 21'88

ব্লবগুলি একে অপরের উপর দিয়ে যেতে পারে প্রাক্তন: ব্লব 1 [0] [0] এ ডানদিকে এবং ব্লব 2 [0] [1] বাম দিকে সরানো হয় বা কম শক্তিযুক্ত ব্লাব খাওয়া হবে?

— fəˈnɛtɪk

সম্পর্কিত

— fəˈnɛtɪk

@ fəˈnɛtɪk হ্যাঁ, বটগুলি একে অপরের উপর দিয়ে যেতে পারে। এছাড়াও, সম্পর্কিত চ্যালেঞ্জটি ছিল আমার (:

— রেডউল্ফ প্রোগ্রামগুলি

3

অন্তর্মূখী

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

প্রযুক্তিগত বিবরণ

এই ফোটাটির মূল বৈশিষ্ট্যটি পৃথক পৃথকভাবে বিভক্ত হওয়া এবং ছড়িয়ে দেওয়া যাতে ব্লবগুলির সম্মিলিত দৃষ্টি সর্বাধিক করা যায়। তাদের মধ্যে দু'টি একটি পেল্টের প্রতিযোগিতা থেকে রোধ করার জন্য এটি একটি সিস্টেমও নিয়োগ করে।

function introvert(mapSize, vision, self, storage) {
  if (!storage.communal.friends)
    storage.communal.friends = {};
  if (!storage.communal.claims)
    storage.communal.claims = {};
  storage.communal.friends[self.uid] = true;
  for (var i in storage.communal.claims)
    if (storage.communal.claims[i] === self.uid) {
      storage.communal.claims = {};
      break;
    }
  var food = {};
  for (var p of vision.pellets) {
    var score = p.energy - taxiDist(p.pos, self.pos);
    if (score > 0)
      food[p.pos] = score;
  }
  var danger = {};
  for (var i = 0; i < mapSize; i++) {
    danger['-1,' + i] = true;
    danger[mapSize + ',' + i] = true;
    danger[i + ',' + mapSize] = true;
    danger[i + ',-1'] = true;
  }
  var relatives = {};
  for (var b of vision.blobs) {
    if (b.uid in storage.communal.friends) {
      relatives[b.pos] = true;
    } else if (!storage.self.justSplit && b.energy < self.energy - taxiDist(b.pos, self.pos) * 0.75) {
      var score = b.energy - taxiDist(b.pos, self.pos) * 1.25;
      if (score > 0)
        food[b.pos] = score;
    } else {
      danger[b.pos] = true;
      danger[b.pos[0] + ',' + (b.pos[1] - 1)] = true;
      danger[b.pos[0] + 1 + ',' + b.pos[1]] = true;
      danger[b.pos[0] + ',' + (b.pos[1] + 1)] = true;
      danger[b.pos[0] - 1 + ',' + b.pos[1]] = true;
    }
  }
  storage.self.justSplit = !danger[self.pos] && self.energy > 150;
  function fromData(n) {
    return n.split(',').map(s => parseInt(s));
  }
  function fs(f) {
    return food[f] / taxiDist(f, self.pos);
  }
  var target = Object.keys(food).filter(f => !(f in storage.communal.claims)).map(fromData).sort((a, b) => fs(b) - fs(a))[0];
  if (target)
    storage.communal.claims[target] = self.uid;
  function ms(m) {
    if (danger[m])
      return 99999999;
    var dists = Object.keys(relatives).map(r => hypotDist(fromData(r), m));
    return (target ? taxiDist(target, m) : 0) - (dists.length ? dists.reduce((a, b) => a + b) / dists.length : 0);
  }
  var candidates = [
    {p: self.pos},
    {p: [self.pos[0], self.pos[1] - 1], d: storage.self.justSplit ? SplitNorth : North},
    {p: [self.pos[0] + 1, self.pos[1]], d: storage.self.justSplit ? SplitEast : East},
    {p: [self.pos[0], self.pos[1] + 1], d: storage.self.justSplit ? SplitSouth : South},
    {p: [self.pos[0] - 1, self.pos[1]], d: storage.self.justSplit ? SplitWest : West}
  ];
  if (storage.self.justSplit)
    candidates.shift();
  return candidates.sort((a, b) => ms(a.p) - ms(b.p))[0].d;
}

— RamenChef
সূত্র

দেখতে দেখতে বেশ সুন্দর বট লাগছে! প্রতিযোগিতাটি শীঘ্রই হওয়া উচিত (আগামীকাল অনুগ্রহের মেয়াদ শেষ হবে)।

— রেডউল্ফ প্রোগ্রামগুলি 21

@ রেডউল্ফপ্রোগ্র্যামস আমি আসলে এটি রানারটিতে পরীক্ষা করেছি এবং এটি সর্বদা বেশ বড় ব্যবধানে জয়ী হয়।

— রামেন শেফ

প্রতি রাউন্ডের গড় স্কোর: 357.544

— রেডওয়ल्फ প্রোগ্রাম

1

অ্যানিমেটেড খাবার

একটি সহজ বট, কেবল প্রতিযোগিতা শুরু করার জন্য। নিকটতম মুদ্রা খুঁজে পায় এবং এটির দিকে যায়। উদাহরণ বট বন্ধ ভিত্তিতে।

function(map, near, me, storage) {
    var targs = near.pellets.map(el => taxiDist(el.pos, me.pos));
    var targ = near.pellets[targs.indexOf(Math.max(...targs))].pos;
    if (targ[0] == me.pos[0])
        return targ[1] < me.pos[1] ? North : South;
    return targ[0] < me.pos[0] ? West : East;
}

— Muffinz72
সূত্র

প্রতি রাউন্ডের গড় স্কোর: 24.933

— রেডওয়ल्फ প্রোগ্রাম

এবং, ইভেন্টগুলির অবাক করার পরিবর্তে (বাগগুলি হ্রাস করতে কিছুটা সংশোধন করা হয়েছে) 5-লাইনার 2 য় জিতেছে

— রেডওয়াল্ফ প্রোগ্রামগুলি

1

ব্লবলিব পরীক্ষক

function(map, near, me, storage) {
    // BlobLib, the main purpose of this post
    const bloblib = {
        // Returns only pellets and blobs that are within the immediate neighbourhood (within 1 space of) me
        getNeighbours: (known) => {
            let neighbours = {};
            neighbours.pellets = known.pellets.filter(x => x.pos[0] >= me.pos[0] - 1 && x.pos[0] <= me.pos[0] + 1 && x.pos[1] >= me.pos[1] - 1 && x.pos[1] <= me.pos[1] + 1);
            neighbours.blobs = known.blobs.filter(x => x.pos[0] >= me.pos[0] - 1 && x.pos[0] <= me.pos[0] + 1 && x.pos[1] >= me.pos[1] - 1 && x.pos[1] <= me.pos[1] + 1);
            return neighbours;
        },
        // Gets the blob or pellet at the given location
        getByPos: (pos, known) => {
            let pellets = known.pellets.filter(x => x.pos[0] == pos[0] && x.pos[1] == pos[1]);
            let blobs = known.blobs.filter(x => x.pos[0] == pos[0] && x.pos[1] == pos[1]);
            if (blobs.length) return blobs[0];
            if (pellets.length) return pellets[0];
            return null;
        },
        // Returns a 2d array of size, containing any known blobs or pellets
        areaMatrix: (size, known) => {
            let matrix = [];
            for (let x = 0; x < size; x++) {
                let row = [];
                for (let y = 0; y < size; y++) {
                    let realPos = [me.pos[0] - (x + Math.floor(size / 2)), me.pos[1] - (y + Math.floor(size / 2))];
                    row.push(getByPos(realPos, known));
                }
                matrix.push(row);
            }
            return matrix;
        },
        // Gets a cardinal direction pointing from from to to
        cardDirTo: (to, from = me.pos) => {
            let diff = bloblib.multiDist(from, to);

            if (diff[0] == 0 && diff[1] == 0) return null;

            if (Math.abs(diff[0]) > Math.abs(diff[1])) {
                // Gunna be east or west
                return diff[0] > 0
                    ? East
                    : West;
            } else {
                return diff[1] > 0
                    ? South
                    : North;
            }
        },
        // Returns a vector of the X and Y distances between from and to
        multiDist: (from, to) => {
            return [to[0] - from[0], to[1] - from[1]]
        },
        // Gets the closest object in objs to position to
        getClosest: (objs, to = me.pos) => {
            if (!objs || !objs.length) return null;

            let sorted = objs.concat().sort((a, b) => taxiDist(a.pos, to) - taxiDist(b.pos, to));
            return sorted[0];
        },
        // Should be run at startup. Calculates which directions are unsafe to move in
        dangerSense: (origin) => {
            let neighbours = bloblib.getNeighbours(near);
            let matrix = bloblib.areaMatrix(3, neighbours);

            if (me.pos[1] == 0 || (matrix[1,0] && isThreat(matrix[1,0]))) bloblib.unsafeDirs.push(North);
            if (me.pos[0] == map - 1 || (matrix[2,1] && isThreat(matrix[2,1]))) bloblib.unsafeDirs.push(East);
            if (me.pos[0] == 0 || (matrix[0,1] && isThreat(matrix[0,1]))) bloblib.unsafeDirs.push(West);
            if (me.pos[1] == map - 1 || (matrix[1,2] && isThreat(matrix[1,2]))) bloblib.unsafeDirs.push(South);
        },
        isThreat: (blob) => {
            if (!blob.uid) return false;
            if (storage.communal.blobs.includes(blob.uid)) return true;

            return blob.energy >= me.energy - 1;
        }
        // Attempts to move in the given direction
        // Rotates the direction 90 if it can't safely move
        attemptMove: (dir = North) => {
            for (let i = 0; i < 4; i++) {
                if (bloblib.unsafeDirs.includes(dir)) dir = modDir(dir, i);
                else return dir;
            }
            return null;
        },
        // Attempts to split in the given direction
        // Rotates the direction 90 if it can't safely split
        attemptSplit: (dir = SplitNorth) => {
            for (let i = 0; i < 4; i++) {
                if (bloblib.unsafeDirs.includes(dir)) dir = modDir(dir, i);
                else return dir;
            }
            return null;
        },
        // Returns the next direction in which to move toward pos
        // Don't bother checking if we have enough energy, because if
        // we have < 1 energy we're basically dead anyway
        moveTo: (pos) => {
            return bloblib.performAction(bloblib.attemptMove(bloblib.cardDirTo(pos)));
        },
        // Simply registers the action in communal history, then returns it unmodified
        performAction: (action) => {
            storage.communal.history[me.uid].push(action);
            return action;
        },

        // Stores directions in which there is another blob
        // This wouldn't make sense to store across turns, so we don't bother
        unsafeDirs: []
    };
    bloblib.dangerSense(me.pos);

    // Register this blob
    if (!storage.communal.blobs) storage.communal.blobs = [];
    if (!storage.communal.blobs.includes(me.uid)) storage.communal.blobs.push(me.uid);

    // Register history for this blob
    if (!storage.communal.history) storage.communal.history = {};
    if (!storage.communal.history[me.uid]) storage.communal.history[me.uid] = [];

    // Split if we can and there are fewer than 10 blobs in our community
    if (me.energy > 150 && storage.communal.blobs.length < 10) {
        let split = bloblib.getSplit();
        if (split) return split;
    }

    // If we can't see any pellets or blobs, don't do anything
    if (!near.pellets.length && !near.blobs.length) return null;

    // Move toward the nearest pellet
    return bloblib.moveTo(bloblib.getClosest(near.pellets));
}

আসল বটটি মোটামুটি সহজ, তবে এটি bloblibঅন্যান্য বটগুলি জুড়ে ব্যবহার এবং বিকাশের পরিকল্পনা করে এমন ক্রিয়াকলাপ এবং কার্যকারিতা সংগ্রহের ধারণার প্রমাণ হিসাবে আরও বেশি নকশা করা হয়েছে (এটি নিজেও ব্যবহার করতে / প্রসারিত করতে নির্দ্বিধায় অনুভব করুন)

সংক্ষেপে, এই বটটি নিম্নলিখিতগুলি করে:

If energy > 150 and blobs_in_team < 10: Try to split
If visible_pellets = 0 and visible_blobs = 0: do nothing
Move toward the closest pellet in a safe way
    that avoids moving into other stronger or equal blobs
    or off the edge of the map

— Skidsdev
সূত্র

আপনি এখন একটি

— ব্লবের

1

শত্রু ব্লবগুলি তাদের শক্তির স্তরের উপর ভিত্তি করে একটি "হুমকি" কিনা তা নির্ধারণ করতে @ রেডউলফপ্রগ্রামগুলি ব্লবলিব আপডেট করেছে।

— স্কিডদেব

প্রতি রাউন্ডের গড় স্কোর: 7.913

— রেডউল্ফ প্রোগ্রামগুলি

এই সিস্টেমটি সম্ভবত কিছু ভাল ব্লব ব্যবহার করা যেতে পারে, তবে এইটিকে কিছুটা অদ্ভুতভাবে অভিনয় বলে মনে হয়েছিল।

— রেডউল্ফ প্রোগ্রামগুলি

1

লোভী কাপুরুষ

import random

def greedy_coward(map_length, near, me, storage):
    interesting_objects = [] #objects I can eat
    bad_objects = [] #objects that eat me
    allowed_directions = ["North", "East", "South", "West"]

    # add pellets to objects that I'm interested in
    for i in near.pellets:
        interesting_objects.append(i)

    # figure out which blobs are good and which are bad
    for i in near.blobs:
        # if I'm under or equal powered, add it to bad_objects
        if i.energy >= me.energy: 
            bad_objects.append(i)
        # if I can eat it, add it to interesting objects.
        else:
            interesting_objects.append(i)

    # if there are any bad objects, process them.
    if not len(bad_objects) == 0:

        # find the nearest bad object and make sure I don't move towards it
        bad_objects_distances = []
        for i in bad_objects:
            bad_objects_distances.append(taxiDist(i.pos, me.pos))
        worst_object = bad_objects[bad_objects_distances.index(min(bad_objects))]

        # find the direction of the worst object
        bad_object_xy_distance = [worst_object.pos[0] - me.pos[1], worst_object.pos[1] - me.pos[1]]
        closest_number = min(bad_object_xy_distance)
        bad_object_direction_vague = [["West","East"],["North","South"]][bad_object_xy_distance.index(closest_number)]
        if closest_number < 0:
            bad_object_direction = bad_object_direction_vague[1]
        else:
            bad_object_direction = bad_object_direction_vague[0]

        # remove bad object direction from allowed directions
        allowed_directions.remove(bad_object_direction)

    # process interesting objects if they exist
    if not len(interesting_objects) == 0:

        # find the nearest interesting object
        interesting_objects_distances = []
        for i in interesting_objects:
            interesting_objects_distances.append(taxiDist(me.pos, i.pos))
            interesting_object = interesting_objects[interesting_objects_distances.index(min(interesting_objects_distances))]

        # find the direction of the best object
            good_object_xy_distance = [interesrting_object.pos[0] - me.pos[1], interesting_object.pos[1] - me.pos[1]]
            closest_number = min(good_object_xy_distance)
            good_object_direction_vague = [["West","East"],["North","South"]][good_object_xy_distance.index(closest_number)]
            if closest_number < 0:
                good_object_direction = good_object_direction_vague[1]
            else:
                good_object_direction = good_object_direction_vague[0]

        # if the good and bad objects are in the same direction, move randomly in a different direction
        if good_object_direction == bad_object_direction:
            return random.choice(allowed_directions)
        else: # otherwise go towards the good object.
            return good_object_direction

    return 0 # when in doubt, stay still

বা, জাভাস্ক্রিপ্টে,

function(map_length, near, me, storage) {
    var interesting_objects = []; //objects I can eat
    var bad_objects = []; //objects that eat me
    var allowed_directions = ["north", "east", "south", "west"];

    //add pellets to objects that I'm interested in
    for (let i in near.pellets) {
        interesting_objects.push(near.pellets[i]);
    }

    //figure out which blobs are good and which are bad
    for (let i in near.blobs) {
        //if I'm under or equal powered, add it to bad_objects
        if (near.blobs[i].energy >= me.energy) {
            bad_objects.push(near.blobs[i]);
        }
        //if I can eat it, add it to interesting objects.
        else {
            interesting_objects.push(near.blobs[i]);
        }
    }

    //if there are any bad objects, process them.
    if (bad_objects.length) {

        //find the nearest bad object and make sure I don't move towards it
        var bad_objects_distances = [];
        for (i in bad_objects) {
            bad_objects_distances.push(taxiDist(bad_objects[i].pos, me.pos));
        }
        var worst_object = bad_objects[bad_objects_distances.indexOf(Math.min(...bad_objects_distances))];

        //find the direction of the worst object
        var bad_object_xy_distance = [worst_object.pos[0] - me.pos[1], worst_object.pos[1] - me.pos[1]];
        var closest_number = Math.min(...bad_object_xy_distance.map(el => Math.abs(el)));
        var bad_object_direction_vague = [["west","east"],["north","south"]][bad_object_xy_distance.map(el => Math.abs(el)).indexOf(closest_number)];
        if (closest_number < 0) {
            var bad_object_direction = bad_object_direction_vague[1];
        } else {
            var bad_object_direction = bad_object_direction_vague[0];
        }

        //remove bad object direction from allowed directions
        allowed_directions = allowed_directions.filter(el => el !== bad_object_direction);

    }

    //process interesting objects if they exist
    if (interesting_objects.length) {

        //find the nearest interesting object
        var interesting_objects_distances = [];
        for (i in interesting_objects) {
            interesting_objects_distances.push(taxiDist(me.pos, interesting_objects[i].pos))
        }
        var interesting_object = interesting_objects[interesting_objects_distances.indexOf(Math.min(...interesting_objects_distances))];

        //find the direction of the best object
        var good_object_xy_distance = [interesting_object.pos[0] - me.pos[1], interesting_object.pos[1] - me.pos[1]];
        var closest_number = Math.min(...good_object_xy_distance.map(el => Math.abs(el)));
        var good_object_direction_vague = [["west","east"],["north","south"]][good_object_xy_distance.map(el => Math.abs(el)).indexOf(closest_number)];
        if (closest_number < 0) {
            var good_object_direction = good_object_direction_vague[1];
        } else {
            var good_object_direction = good_object_direction_vague[0];
        }

        //if the good and bad objects are in the same direction, move randomly in a different direction
        if (good_object_direction == bad_object_direction) {
            return allowed_directions[allowed_directions.length * Math.random() | 0];
        } else{ //otherwise go towards the good object.
            return good_object_direction;
        }

    }

    return 0; //when in doubt, stay still
}

এই বট খুব আকর্ষণীয় নয়। এটি দুটি অগ্রাধিকার অনুযায়ী কাজ করে:

খাবেন না।
নিকটতম জিনিস খাওয়া।

এটি অন্যান্য জিনিস খাওয়ার ক্ষমতা সর্বাধিক করে তোলা

— কমরেড স্পার্কলপনি
সূত্র

আমি এটি অনুবাদ কাজ পাবেন! আমি শেষ করার পরে, আমি জেএস সংস্করণ সহ একটি সম্পাদনার পরামর্শ দেব।

— রেডউল্ফ প্রোগ্রামগুলি

রেডউল্ফপ্রগ্রামগুলি ভালো লাগছে, আপনাকে অনেক ধন্যবাদ।

— কমরেড স্পার্কলপনি

আমার মনে হয় আসলে কোনও ভাল / খারাপ জিনিস আছে কিনা তা পরীক্ষা করার জন্য আপনাকে একটি / যুক্ত করতে হবে। এটি জেএস সংস্করণে বেশ কয়েকটি সমস্যা সৃষ্টি করছে।

— রেডউল্ফ প্রোগ্রামগুলি 21 '11

রেডউल्फপ্রগ্রামসমূহ এটি এখনই ঠিক করা উচিত। আমি কেবলমাত্র একটি if স্টেটমেন্ট যুক্ত করেছি যা আকর্ষণীয় এবং খারাপ জিনিসের তৈরি তালিকাটি খালি নয় তা নিশ্চিত করার জন্য তা পরীক্ষা করে। আবার, সহায়তার জন্য আপনাকে ধন্যবাদ।

— কমরেড স্পার্কলপনি

@ রেডওলফপ্রোগ্রামস আপনার কাছে জেএস সংস্করণ প্রস্তুত আছে কি?

— রামনেন শেফ

1

SafetyBlob

এই বটটি আগের KOTH থেকে Safecoin হিসাবে একই ধরণের কিছু যুক্তি ব্যবহার করে।

এটি কীভাবে কাজ করে

এই বোটটি খাবারের দিকে এগিয়ে যাবে যা এটি কোনও বড় বট করার আগে বা একই সাথে / ছোট বোটের আগে পৌঁছতে পারে। যদি এই খাবারগুলির মানদণ্ডগুলি পূরণ করে এমন কোনও খাবার দেখতে না পান তবে এটি এলোমেলো পথে চলে যাবে (কেন্দ্রের দিকে পক্ষপাতদুষ্ট)। যদি এটি 150 শক্তি হয়ে যায় এবং নিরাপদ খাবার দেখতে না পারে, তবে এটি স্থানান্তরিত করতে নিরাপদ হিসাবে লেবেলযুক্ত এক দিক থেকে বিভক্ত হবে।

এই বটটি তার নিজস্ব বাচ্চাদের খোঁজ রাখে না তবে সুরক্ষা ব্যবস্থার কারণে তাদের কোনওভাবেই সংঘর্ষে পড়া উচিত নয়।

 function SafetyBlob(map,local,me,stor){
  var center=(map/2|0)+1;
  var [x,y]=me.pos
  var uid=me.uid
  var others=local.blobs;
  var pellets=local.pellets;
  //Bot doesnt use storage because it just tries to find what it can.
  var willSplit=me.energy>150;
  var bestSafePelletValue=0;
  var bestSafePellet=null;
  var pellet;
  var other;
  //Head towards the best valued pellet (energy/distance) which can be reached before any larger or equal sized blobs or can be reached at the same time as smaller blobs
  for(i=0;i<pellets.length;i++){
    pellet=pellets[i]
    if(bestSafePelletValue<=pellet.energy/taxiDist(pellet.pos,me.pos)){
      for(j=0;j<others.length;j++){
        other=others[j];
        if(other.energy<me.energy){
          if(taxiDist(pellet.pos,me.pos)<=taxiDist(other.pos,pellet.pos)){
            if(taxiDist(pellet.pos,me.pos)<taxiDist(bestSafePellet.pos,me.pos)){
              bestSafePellet=pellet;
              bestSafePelletValue=pellet.energy/taxiDist(pellet.pos,me.pos);
            }
          }
        }
        if(other.energy>=me.energy){
          if(taxiDist(pellet.pos,me.pos)<taxiDist(other.pos,pellet.pos)){
            if(taxiDist(pellet.pos,me.pos)<taxiDist(bestSafePellet.pos,me.pos)){
              bestSafePellet=pellet;
              bestSafePelletValue=pellet.energy/taxiDist(pellet.pos,me.pos);
            }
          }
        }
      }
    }
  }

  if(bestSafePellet){
    [xPellet,yPellet]=bestSafePellet.pos;
    if(x<xPellet&&Math.abs(x-xPellet)>=Math.abs(y-yPellet)){
      return East;
    }
    if(x<xPellet&&Math.abs(x-xPellet)>=Math.abs(y-yPellet)){
      return West;
    }
    if(y<yPellet&&Math.abs(x-xPellet)<Math.abs(y-yPellet)){
      return South;
    }
    if(y<yPellet&&Math.abs(x-xPellet)<Math.abs(y-yPellet)){
      return North;
    }
  }
  
  var validMoves=["North","East","South","West","Stay"];
  var removeIndex=0;
  var safeEnergy;
  if(x==0)
    validMoves.splice(validMoves.indexOf("West"));
  if(x==map)
    validMoves.splice(validMoves.indexOf("East"));
  if(y==0)
    validMoves.splice(validMoves.indexOf("North"));
  if(y==map)
    validMoves.splice(validMoves.indexOf("South"));

  var possibleMoves=[...validMoves];
  possibleMoves.splice(possibleMoves.indexOf("Stay"));
  //If there is no safe pellet try to stick somewhat towards the middle
  //Ignore enemies unless at 2 distance from self and there is no safe pellet
  for(i=0;i<others.length;i++){
    other=others[i];
    safeEnergy=willSplit?(me.energy-50)/2:me.energy;
    if((other.energy>=safeEnergy)&&(taxiDist(me.pos,other.pos)<=2)){
      if(taxiDist(me.pos,other.pos)==1){
        if((removeIndex=validMoves.indexOf("Stay"))>=0){
          validMoves.splice(removeIndex,1)
        }
      }
      if(other.pos[0]<x){
        if((removeIndex=validMoves.indexOf("West"))>=0){
          validMoves.splice(removeIndex,1)
        }
      }
      if(other.pos[1]<y){
        if((removeIndex=validMoves.indexOf("South"))>=0){
          validMoves.splice(removeIndex,1)
        }
      }
      if(other.pos[0]>x){
        if((removeIndex=validMoves.indexOf("East"))>=0){
          validMoves.splice(removeIndex,1)
        }
      }
      if(other.pos[1]>y){
        if((removeIndex=validMoves.indexOf("North"))>=0){
          validMoves.splice(removeIndex,1)
        }
      }
    }
  }
  //If there are no safe moves move in a random direction (Reduce energy as much as possible with a slight chance of survival)
  if(!validMoves.length){
    switch (possibleMoves[Math.random()*possibleMoves.length|0]){
      case "North":
        return North;
      case "South":
        return South;
      case "East":
        return East;
      case "West":
        return West;
    }
  }
  //If there are safe moves bias towards moving towards the center block of 1/3 of the way from the sides
  if(!willSplit){
    //bias moving towards near the center
    biasedMoves=[];
    for(var i=0;i<validMoves.length;i++){
      switch(validMoves[i]){
        case "North":
          biasedMoves=biasedMoves.concat(y>center?"0".repeat(center/3|0).split``:"0".repeat(y-center).split``);
          break;
        case "South":
          biasedMoves=biasedMoves.concat(y<center?"2".repeat(center/3|0).split``:"2".repeat(center-y).split``);
          break;
        case "East":
          biasedMoves=biasedMoves.concat(y>center?"1".repeat(center/3|0).split``:"1".repeat(x-center).split``);
          break;
        case "West":
          biasedMoves=biasedMoves.concat(y<center?"3".repeat(center/3|0).split``:"3".repeat(center-x).split``);
          break;
        case "Stay":
          biasedMoves=biasedMoves.concat(["4"]);
          break;
      }
    }
  }
  if(willSplit){
    switch (biasedMoves[Math.random()*biasedMoves.length|0]){
      case "0":
        return SplitNorth;
      case "2":
        return SplitSouth;
      case "1":
        return SplitEast;
      case "3":
        return SplitWest;
      case "4":
        return Stay;
    }
  }
  else{
    switch (biasedMoves[Math.random()*biasedMoves.length|0]){
      case "0":
        return North;
      case "2":
        return South;
      case "1":
        return East;
      case "3":
        return West;
      case "4":
        return Stay;
    }
  }
}

— fənɛtɪk
সূত্র

আমি ইতিমধ্যে নিয়ামকটি চালিয়েছি, তবে আমি এই নতুন বট দিয়ে আবার এটি করতে পারি। জিতলে অনুগ্রহটি পুনরায় নিয়োগ করতে খুব দেরি হয়ে গেছে তবে ফলাফলটি সম্পর্কে আমি কৌতূহলী।

— রেডউল্ফ প্রোগ্রামগুলি

@ রেডউল্ফপ্রোগ্রামগুলি লক্ষ্যটি অনুগ্রহ অর্জন করা নয়।

— fəˈnɛtɪk

আমি জানি, কেবল আপনি নিশ্চিত তা নিশ্চিত করেছেন (:

— রেডউল্ফ প্রোগ্রামগুলি

ক্ষুধার্ত ব্লবস কোথ

শক্তি এবং আন্দোলন

আহার

সনাক্তকরণ এবং তথ্য

বিদারক

শক্তি স্থানান্তর

ফাংশন, স্টোরেজ এবং ইউআইডি

রিটার্ন মান

পূর্বনির্ধারিত গ্রন্থাগার ফাংশন

উদাহরণ ব্লব

বিধি

অন্তর্মূখী

প্রযুক্তিগত বিবরণ

অ্যানিমেটেড খাবার

ব্লবলিব পরীক্ষক

লোভী কাপুরুষ

SafetyBlob

এটি কীভাবে কাজ করে