43

এই চ্যালেঞ্জ শেষ হয়েছে। প্রতিযোগীদের চূড়ান্ত স্কোর দেখতে, এখানে ক্লিক করুন

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

উদ্দেশ্য:

একাধিক রাউন্ডে 1000 টি পর্যন্ত টার্ন রয়েছে (যখন কেবলমাত্র একটি বট বাকী থাকে তখন শেষ হয়), সর্বোচ্চ মোট মূল্যযুক্ত বট (প্রাপ্ত সমস্ত সোনার যোগফল) বিজয়ী।

পালা:

প্রতিটি ঘুরে, জীবিত প্রতিটি বট (> 0 এইচপি) একবার চালানো হবে। এটি কোনও পদক্ষেপ ফিরিয়ে দিতে পারে, যা নিম্নলিখিতগুলির মধ্যে একটি হতে পারে:

নিরাময়: পুনরায় এইচপি
আক্রমণ: অন্য বট থেকে এইচপি সরিয়ে দেয়
ঝাল: পরবর্তী আক্রমণগুলির বিরুদ্ধে রক্ষা করে
স্টান: অন্য বটের পরবর্তী পালাটি এড়িয়ে যায়
ফার্ম: এইচপি দামে সোনার আয় হয়
আপগ্রেড: নির্দিষ্ট পদক্ষেপগুলি আরও ভাল করুন

সমস্ত বটগুলি কার্যকর হওয়ার আগে তাদের চলন ফিরিয়ে দেবে, সুতরাং কোনও স্তম্ভ, নিরাময়, আক্রমণ, ,াল ইত্যাদির পরে সেই মোড়ের পরে চলমান কোনও বটকে প্রভাবিত করবে না। উদাহরণস্বরূপ, বট এ যদি বট বিটিকে স্টান করে এবং বট বি টার্ন ক্রমে বট এ এর পরে হয় তবে বট বি একই পরে আবার পরে যাবে এবং পরের বারে স্টানটি ঘটবে।

যুদ্ধ, কৃষিকাজ এবং আপগ্রেডিং:

প্রতিটি বটের সর্বোচ্চ 100 টি এইচপি থাকে এবং 0 এবং 99 এর মধ্যে একটি নির্ধারিত ইউআইডি থাকে This এই ইউআইডি প্রতিটি রাউন্ডের পরে পরিবর্তিত হয় এবং বটগুলি কীভাবে একে অপরকে ট্র্যাক রাখে।

নিরাময় হ'ল অন্যতম সরল পদক্ষেপ যা এর স্তর দ্বারা নির্ধারিত পরিমাণে এইচপি যুক্ত করে (5 এইচপি থেকে শুরু হয়)। একটি বট 100 টি এইচপি অতীতে নিরাময় করতে পারে না।

তার ইউআইডি দ্বারা বট আক্রমণ করা আরও একটি সম্ভাব্য পদক্ষেপ, স্তরটিতে 5 এইচপি এর বেস ক্ষতি সহ। বটগুলি স্তম্ভিত হয়ে যেতে পারে, তাদের পরবর্তী পালাও এড়িয়ে যায়, যা ইউআইডিও ব্যবহার করে।

বটের অতিরিক্ত ঝাল এইচপি থাকে, যার কোনও সীমা নেই। এই ঝাল এইচপি অন্যান্য বট থেকে সরাসরি আক্রমণ থেকে ক্ষতি শোষণ করবে এবং shাল দিয়ে যুক্ত করা হবে। 0 স্তরে, শিল্ডিং 5 টি শিল্ড এইচপি যুক্ত করে।

কৃষিতে 2 এইচপি ব্যয়ে 0 স্তরে 5 স্বর্ণ উপার্জন হবে। এই 2 এইচপি রক্ষা করা যাবে না। সোনার জন্য একমাত্র ব্যবহার (জয়ের বাইরে) চালগুলি আপগ্রেড করা। নিরাময়, আক্রমণ এবং ঝালাইয়ের মূল মূল্য 5 এইচপি হয় এবং 5 টি স্বর্ণ থেকে কৃষিকাজ শুরু হয়। এই পদক্ষেপগুলির প্রত্যেকের স্বতন্ত্র স্তর রয়েছে, যা 0 থেকে শুরু হয় formula

হিলিং: L + 5
অ্যাটাকিং: 1.25L + 5
সুরক্ষা কবচ: 1.5L + 5
কৃষিকাজ: 2L + 5

যে কোনও পদক্ষেপের আপগ্রেড করার ব্যয় একটি নির্দিষ্ট স্তরের জন্য সমান এবং এটি নির্ধারিত হয় 2.5L² + 2.5L + 10, যেখানে এল বর্তমান স্তর। এটি cost(currentLevel)নির্ধারণ করতে একটি বট শর্টকাট হিসাবে ফাংশনটি ব্যবহার করতে পারে ।

বুটগুলি 25 টি স্বর্ণ দিয়ে শুরু হয়, যার ফলে তারা দুটি পদক্ষেপকে দ্রুত স্তরের 1 এ উন্নীত করতে পারে বা একটি স্তরকে 2 স্তরে উন্নতি করতে পারে This এই শুরুর সোনার বটগুলি মোট মূল্য হিসাবে গণনা করা হয় না। একটি বট হত্যা আপনি গোল্ড আপ এর মোট মূল্য অর্ধেক দেয়, এবং যদি দুটি বট একই পালা অন্য হত্যা, তারা উভয় পুরষ্কার পাবেন।

ইনপুট আউটপুট:

নিয়ামকের সাথে যোগাযোগের জন্য, ফাংশনের রিটার্ন মানটি সরানো তথ্য প্রেরণে ব্যবহৃত হয়। এর মধ্যে একটি ফেরত দেওয়া উচিত:

সুস্থ heal()
আক্রমণ: attack(uid)
রক্ষা করুন shield()
অচেতন: stun(uid)
কৃষি: farm()
আপগ্রেড করুন: upgrade("heal" / "attack" / "shield" / "farm")

কোনও পালা (কিছু করবেন না) এড়ানোর জন্য, কিছুই ফিরিয়ে দিন না, বা মিথ্যা মানটি ফিরিয়ে দিন।

বর্তমান টার্ন নম্বর পেতে (1 এ শুরু), ব্যবহার করুন turn()।

আপনার ফাংশনটির যুক্তিগুলির মধ্যে আপনার বট, অন্যান্য বটের ইউআইডি এবং টার্ন-স্টোর স্টোরেজ সম্পর্কিত তথ্য অন্তর্ভুক্ত থাকবে। প্রথম আর্গুমেন্ট নিম্নলিখিত বৈশিষ্ট্য সঙ্গে একটি বস্তু হল: uid, hp, goldএবং shield। এগুলি আপনার বটের বর্তমান তথ্যের অনুলিপি। এছাড়া একটি নেস্টেড বস্তুর levelsমাত্রা সংখ্যার সঙ্গে, heal, attack, shield, এবং farm।

দ্বিতীয় যুক্তি সব জীবিত পুলিশের ছাড়া অন্য বট একটি এলোমেলো অ্যারে, একটি অবজেক্ট বৈশিষ্ট্যাবলী ধারণকারী হিসাবে ফরম্যাট করা uid, hp(প্লাস ঢাল), worthএবং attack(হামলা স্তর)। তৃতীয় আর্গুমেন্ট একটি খালি বস্তু যা টার্ন-স্টোরেজ স্টোরেজের জন্য ব্যবহার করা যেতে পারে।

উদাহরণস্বরূপ:

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

function freeTestBotA(me, others, storage) {
    if (me.levels.attack < 5) {
        if (me.gold < cost(me.levels.attack))
            return farm();
        return upgrade("attack");
    }
    return attack(others[0].uid);
}

এই বোটটির দুটি মোড রয়েছে: আপত্তিকর এবং প্রতিরক্ষামূলক। এটি হয় একটি এলোমেলো বট স্তম্ভিত করবে বা প্রতিরক্ষামূলক মোডে থাকাকালীন নিরাময় করবে এবং আক্রমণাত্মক মোডে আসার পরে এটি আক্রমণ বা ঝাল করবে। এটি যখনই সম্ভব এটির আক্রমণগুলিকে আপগ্রেড করার চেষ্টা করবে।

function freeTestBotB(me, others, storage) {
    if (me.gold >= cost(me.levels.attack))
        return upgrade("attack");
    if (me.hp < 50)
        if (Math.random() < 0.5)
            return stun(others[0].uid);
        else
            return heal();
    else
        if (Math.random() < 0.5)
            return attack(others[0].uid);
        else
            return shield();
}

নিয়মাবলী:

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

নতুন নিয়ামক ডিবাগিং:

ফাইলটি ব্যবহার করে gold-battle-log.js, আপনি debugএকটি বটের সম্পত্তির মান botData0 (লগিং নেই), 1 (লগ চালনা), বা 2 (লগ মুভ, এইচপি, সোনার, স্তর ইত্যাদি) এ সেট করতে পারেন

চ্যালেঞ্জটি 9 ই আগস্ট শুক্রবার 1700 ইউটিসি-তে শেষ হবে

king-of-the-hill javascript

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

4

সমস্ত বট সঙ্গে একটি গিস্ট তৈরি। gist.github.com/Draco18s/2efbf95edcf98d6b1f264e26bbb669d1 আমি এটি আপডেট রাখার চেষ্টা করব (তবে এটি যদি শালীন শুরু না হয়)

— Draco18s

4

বটগুলির সাথে অটো-আপডেটিং কন্ট্রোলার অন্তর্ভুক্ত রয়েছে: redwolfprogram.com/koth

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

4

আমি এই প্রশ্নটি বন্ধ করতে ভোট দিচ্ছি কারণ এটি ইতিমধ্যে ডি-ফ্যাক্টো নতুন জবাব বন্ধ করেছে ("এই চ্যালেঞ্জটি শেষ হয়ে গেছে। চূড়ান্ত স্কোরগুলি দেখতে ...")

— পিপ্প্রি

3

@pppery আপনি না পারেন? আমি অ-প্রতিযোগিতামূলক উত্তরের সাথে ভাল থাকব, এবং [closed]শেষের দিকে নৈমিত্তিক দর্শকদের আমার চ্যালেঞ্জটি পড়ার কারণে এড়িয়ে যেতে পারে যেহেতু তারা কম মানের বা অফ-টপিক বলে ধরে নিচ্ছে ।

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

5

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

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

16

Unkillable

Undyable থেকে কাঁটাচামচ ।

function UnkillableBot(me){
    if(me.hp <= 100 - (me.levels.heal + 5)){
        return heal()
    }else if(turn() % 10 == 0 && me.shield < 800) {
        return shield()
    }else{
        if(me.gold >= cost(me.levels.shield) && me.levels.shield <= 9){
            return upgrade("shield")
        }else if(me.gold >= cost(me.levels.farm)){
            return upgrade("farm")
        }else{
            if(me.shield < 500 && me.levels.shield > 4) {
                return shield()
            }
            return farm()
        }
    }
}

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

— Draco18s
সূত্র

সম্পূর্ণরূপে আমার পরীক্ষাগুলিতে প্রতিযোগিতা পিষে

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

1

আমি মনে করি যে প্রথম ifবয়ানটি ব্যবহার করা থাকলে এই বটটি আরও শক্তিশালী হতে পারে <=- বর্তমানে এটি কখনই পূর্ণ হবে না।

— স্কুট

@ স্কুটস এটি কতটা গুরুত্বপূর্ণ তা নিশ্চিত নয়, তবে আমি এটি পরিবর্তন করব change

— ড্রাকো 18s 13

2

@ ড্রাকো 18 আমি নিশ্চিত যে এটি খুব অল্প পরিমাণে গুরুত্বপূর্ণ - তবে এই সাইটটি কি সামান্য সামান্য ব্যবহারিকভাবে তুচ্ছ উন্নতির বিষয়ে নয়? :)

— স্কুটগুলি

@ স্কুটস সর্বাধিক স্বাস্থ্যের নিরাময় এই চ্যালেঞ্জের পক্ষে খুব বেশি কিছু নয় কারণ আসল আক্রমণাত্মক হুমকি নেই। সত্যিকারের আপত্তিকর একমাত্র বট হ'ল বুলিবট এবং আপনি তাকে সম্পর্কে সত্যই কিছু করতে পারবেন না। এটি পুরোপুরি স্বাস্থ্য থেকে যাওয়ার জন্য কার্যকারিতা হ্রাস করতে পারে।

— বি0আরডিআরএস

13

ThanosBot

function ThanosBot(me, others, storage){
    if(turn()==1){
        storage.origPopulation = others.length;
        return upgrade("attack");
    }

    if (others.length < storage.origPopulation / 2)
    {
        if(me.hp <= 100 - (me.levels.heal + 5)){
            return heal();
        }
        else {
            return farm();
        }
    }

    if(me.hp <= 100 - (me.levels.heal + 5)){
        return heal()
    }else{
        if(me.gold >= cost(me.levels.attack)){
            return upgrade("attack")
        }else if(me.gold >= cost(me.levels.heal)){
            return upgrade("heal")
        }else if(me.gold >= cost(me.levels.farm)){
            return upgrade("farm")
        }else{
            if(Math.random() < 0.5){
                return attack(others[0].uid);
            }
            else{
                return farm();
            }
        }
    }
}

অনেকগুলি বট রয়েছে, ঘুরে দেখার মতো পর্যাপ্ত সোনা নেই। এই বট একটি সমাধান প্রস্তাব।

গণহত্যা, হ্যাঁ, তবে এলোমেলো, বিদ্বেষপূর্ণ, ধনী ও দরিদ্র সবার পক্ষে ন্যায়বিচার।

তারা তাকে পাগল বলে অভিহিত করে।

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

জনসংখ্যার ৫০% কেটে ফেলা হলে, জন্ম নেওয়া বটগুলি কেবল পুরো পেট এবং পরিষ্কার আকাশ জানবে, সে কৃষিক্ষেত্রে ফিরে যাবে এবং কৃতজ্ঞ মহাবিশ্বের উপর সূর্য উদয় দেখবে। তিনি সম্পূর্ণরূপে শান্তবাদী হয়ে উঠবেন, কেবল নিজেকে উদ্ভিজ্জ স্যুপ এবং চাষ দিয়ে নিরাময় করবেন।

— কাইতো বাচ্চা
সূত্র

6

আমি "আক্রমণ" এর নাম পরিবর্তন করে "স্ন্যাপ" করতে প্রলুব্ধ হলাম

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

11

কিল স্টিলার

function killStealer({hp, gold, attack:atck, shield:shld, levels:{heal:lHeal, shield:lShld, farm:lFarm, attack:lAtck}}, es, S) {
  let saneReduce = (a, f, n) => a.length? a.reduce(f) : n;
  let t = turn();
  if (t===1) {
    S.worth = 0;
    S.pHP = 100;
    S.pGold = 0;
    S.stat = {};
    S.pT = 0;
    for (let e of es) S.stat[e.uid] = {kills:0, seen:0};
  }

  let pT = S.pT;
  S.pT = t;

  let shp = shld+hp;

  let healP = lHeal      + 5;
  let shldP = lShld*1.5  + 5;
  let farmP = lFarm*2    + 5;
  let atckP = lAtck*1.25 + 5;
  let pheal = () => hp<5  ||  Math.min(100, hp+healP)-hp > shldP? heal() : shield();

  let attacked = S.pHP-hp-shld > 2;
  S.pHP = hp+shld;

  if (gold>S.pGold  &&  t!=1) S.worth+= gold-S.pGold;
  S.pGold = gold;

  let pes = S.pEs;
  let ces = {};
  for (let e of es) ces[e.uid] = {uid:e.uid, hp:e.hp, worth:e.worth};
  S.pEs = ces;

  if (t === 1) return shield(); // to not break things depending on previous frame

  if (t == pT+1) {
    for (let uidE in pes) {
      let e = pes[uidE];
      if (!ces[uidE]) { // dead
        if (e.worth < 30) continue; // don't bother, because others probably won't
        for (let a of es) {
          let pa = pes[a.uid];
          if (a.worth >= pa.worth + e.worth/2 - 2) {
            S.stat[a.uid].kills++;
          }
          if (a.worth != pa.worth || a.hp > pa.hp) S.stat[a.uid].seen++;
        }
      }
    }
  }


  let attackers = es.filter(c => {
    let k = S.stat[c.uid].kills;
    let s = S.stat[c.uid].seen;
    return k > 1  &&  k > s*.7;
  });
  let maxDmg = es.map(c=>c.attack).reduce((a, b) => Math.max(a, b), 0)*1.25 + 5;
  for (let e of es) {
    if (e.worth < farmP) continue;
    let p = pes[e.uid];
    let dmg = p.hp-e.hp;
    if (e.hp <= atckP) {
      return attack(e.uid);
    }
    if (e.hp-dmg-atckP <= 0) {
      return attack(e.uid);
    }
    if (e.hp-maxDmg-atckP <= 0) {
      return attack(e.uid);
    }
    if (e.hp-maxDmg-dmg <= 0) {
      return attack(e.uid);
    }
  }
  if (attackers.length>0 && t>50) {
    for (let e of es) {
      if (e.hp - maxDmg*2 - atckP <= 0  &&  e.worth > 200) {
        let worst = saneReduce(attackers.filter(c => c.hp > 80), (a, b)=>a.worth>b.worth? a : b, null);
        if (worst) return stun(worst.uid);
      }
    }
  }



  if (t < 60  &&  t%5 == 1) return shield();
  if (t === 2) return upgrade("heal");
  if (t === 3) return upgrade("farm");
  if (t%10 == 1) return shield();

  if (gold>=cost(lShld) && lFarm>-2) return upgrade("shield");
  if (gold>=cost(lFarm) && !attacked) return upgrade("farm");

  if (es.length > 2) {
    let notDead = es.filter(c => c.hp > 20);
    if (notDead.length !== 0) {
      notDead.sort((a, b) => a.hp-b.hp);
      if (notDead[Math.min(2, notDead.length-1)].hp > shp) {
        return pheal();
      }
    }
  }


  if (gold>=cost(lHeal)  &&  lHeal+5 < lFarm) return upgrade("heal");
  if (gold>=cost(lAtck)  &&  lAtck+5 < lFarm  &&  es.every(c=>c.attack<=lAtck+2)) return upgrade("attack");

  if (lShld>5  &&  shp < 205+healP+t  &&  shp < 600+t*5) return pheal();
  if (es.every(c => c.worth < S.worth+farmP) && es.length>2 && t<100 && lShld<6) return pheal();
  if (shp<=120  ||  hp<5) return pheal();
  return farm();
}

এখন শুধু চুরি করে মেরে না, চুরি করে মেরেও খুন!

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

— dzaima
সূত্র

এটি কাজ করে কারণ একটি হত্যাকাণ্ডের সাথে জড়িত সমস্ত বট পুরো পুরষ্কার পায়।

— Draco18s

@ ড্রাকো 18 আমি বুঝতে পারি যে এটি কেন ভাল হতে পারে, আমি কেবলমাত্র এত সহজ ধারণাটি আশা করি না যে পরবর্তী সেরা বটের গড় 2x স্কোর (এটি তৈরির সময়) পাওয়া যাবে।

— zaiজিমা

হেই, এটাই ফর্সা। আমি যখন করতে পারি তখন আমাকে সমস্ত বটগুলি ডাউনলোড করতে হবে এবং আমি আরও একটি সমাধান খুঁজে পেতে পারি কিনা তা দেখতে হবে।

— Draco18s

9

ইকুয়ালাইজার

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

function equalizer(me, others, storage){
  if(storage.agroKilled == null)storage.agroKilled = false;
  if(!storage.agroKilled){
    if(storage.blacklist == null)storage.blacklist = [];
    if(storage.lastAttack == null)storage.lastAttack = -1;
    var maxAtk = 0;
    var maxAtkUid = -1;
    var maxAtkHealth = 0;
    for(var i = 0; i < others.length; i++)if(others[i].uid == storage.lastAttack){
      maxAtk = others[i].attack*1.25+5;
      maxAtkUid = storage.lastAttack;
      maxAtkHealth = others[i].hp;
    }
    for(var i = 0; i < others.length; i++){
      if(storage.lastAttack == others[i].uid && others[i].hp >= storage.lastHealth){
        maxAtk = 0;
        maxAtkUid = -1;
        maxAtkHealth = 0;
        storage.blacklist.push(others[i].uid);
      }
    }
    storage.lastAttack = -1;
    var willHeal;
    for(var i = 0; i < others.length; i++)if(others[i].attack*1.25+5 > maxAtk){
      willHeal = false
      for(var j = 0; j < storage.blacklist.length; j++)if(others[i].uid==storage.blacklist[j])willHeal = true;
      if(!willHeal){
        maxAtk = others[i].attack*1.25+5;
        maxAtkUid = others[i].uid;
        maxAtkHealth = others[i].hp;
      }
    }
    if(me.hp < maxAtk) return heal();
    if(me.hp <= 100 - me.levels.heal - 5) return heal();
    var target = -1;
    var targetWorth = me.levels.farm * 2 + 5;
    for(var i = 0; i < others.length; i++) {
      if (others[i].hp <= maxAtk && others[i].worth / 2 > targetWorth) {
        target= others[i].uid;
          targetWorth = others[i].worth / 2;
      }
    }
    if(target!=-1) return attack(target);
    if(me.gold >= cost(me.levels.attack)) return upgrade("attack");
    if(me.levels.heal + 7 < me.levels.attack && me.levels.heal < 9 && me.gold >= cost(me.levels.heal)) return upgrade("heal");
    if(maxAtkUid!=-1){
      storage.lastAttack = maxAtkUid;
      storage.lastHealth = maxAtkHealth;
      return attack(maxAtkUid);
    }
    storage.agroKilled = true;
  }
  if(me.hp < 30) return heal();
  if(me.gold > cost(me.levels.farm)) return upgrade("farm");
  return farm();
}

— B0RDERS
সূত্র

8

আশাবাদী

function Optimist(me, others, storage) {
    if (me.hp < 10)
        return heal();
    if ( (me.hp + me.shield) < 50 )
        return shield();
    if (me.gold >= cost(me.levels.farm) && cost(me.levels.farm) < 0.8 * (1000 - turn()))
        return upgrade("farm");
    rich_bots = others.sort( (x,y) => y.worth - x.worth );
    potential_victim = rich_bots.find( bot => bot.hp <= me.levels.attack * 1.25 + 5 );
    if (potential_victim)
        return attack(potential_victim.uid);
    if (me.gold < rich_bots[0].worth + cost(me.levels.farm) + 25)
        return farm();
    if (me.levels.heal < me.levels.farm)
        return upgrade("heal");
    if (me.levels.shield < me.levels.heal)
        return upgrade("shield");
    if (me.levels.attack < me.levels.shield)
        return upgrade("attack");
    return shield();
}

ধরে নেওয়া যায় এটি শান্তিপূর্ণভাবে কৃষিক্ষেত্রের ৮০% সময় ব্যয় করতে সক্ষম হবে, তাই এটি সর্বাধিক কৃষিকাজ শুরু করে এবং এরপরেই তার যুদ্ধ দক্ষতার দিকে কোনও মনোযোগ দেওয়া শুরু করে। নিশ্চয় কিছুই ভুল হবে না!

— histocrat
সূত্র

8

সহায়তা হত্যা

function KillAssist(me, others, storage) {
  let t = turn();
  if (t===1) {
    storage.worth = 0;
    storage.pHP = 100;
    storage.pGold = 0;
  }
  let hp = me.hp;
  let gold = me.gold;
  let shld = me.shield;
  let lHeal = me.levels.heal+0.25;
  let lFarm = me.levels.farm;
  let lShld = me.levels.shield;
  let lAtck = me.levels.attack;
  let healPower = lHeal      + 4.75;
  let shldPower = lShld*1.5  + 5;
  let farmPower = lFarm*2    + 5;
  let atckPower = lAtck*1.25 + 5;

  let dmgTaken = storage.pHP-(hp+shld);
  let attacked = dmgTaken > 2;
  storage.pHP = (hp+shld);

  if (gold > storage.pGold) storage.worth+= gold-storage.pGold;
  if (gold-storage.pGold > farmPower+5)  storage.lastAtck = -10;
  storage.pGold = gold;
  let pOthers = storage.pOthers;
  storage.pOthers = {};
  for (let o of others) {
    storage.pOthers[o.uid] = {hp: o.hp, uid: o.uid, worth: o.worth};
  } 

  if (t === 1 || t === 2) return upgrade("shield");
  if (t === 3) return shield();

  let maxdmg = others.map(c=>c.attack).reduce((a, b) => Math.max(a, b))*1.25 + 5;
  let lowhp = others.map(c=>c.hp).reduce((a, b) => Math.min(a, b));
  let lowhpid = others.find(c=>c.hp == lowhp).uid;
  let maxAttacker = others.find(o => o.attack*1.25 + 5 == maxdmg).uid;
  for (let o of others) {
    if (o.hp < atckPower  &&  o.worth > farmPower) {
      storage.dead = o.uid;
      storage.deadWorth = o.worth;
      return attack(o.uid);
    }
    let pO = pOthers[o.uid];
    let dmg = pO.hp - o.hp;
    if (o.hp - dmg - atckPower <= atckPower && o.worth >= farmPower) {
      storage.dead = o.uid;
      storage.deadWorth = o.worth;
      return attack(o.uid);
    }
    if (o.hp - maxdmg - atckPower <= atckPower && o.worth >= farmPower) {
      storage.deadWorth = o.worth;
      return attack(o.uid); 
    }
  }
  let lowhpdiff = Math.max(pOthers[lowhpid].hp - others.find(o => o.uid == lowhpid).hp,0);
  if (others.some(o => o.hp > maxdmg && o.hp < lowhpdiff*2+atckPower+maxdmg && o.worth > farmPower)) {
    let bad = others.reduce((a, b) => a.worth>b.worth? a : b);
    let bad2 = others.reduce((a, b) => bad.uid == b.uid ? a : (bad.uid == a.uid ? b : (a.worth>b.worth ? a : b)));
    if(bad.worth < bad2.worth*3 && bad.hp >= (maxdmg+atckPower)*2 && bad.uid != maxAttacker && bad.uid != lowhpid) {
      return stun(bad.uid);
    }
    if(bad2.hp >= (maxdmg+atckPower)*2 && bad2.uid != maxAttacker && bad.uid != lowhpid) {
      return stun(bad2.uid);
    }
  }

  if (t%10 == 9  &&  lShld>4) return shield(); // slowly build up shield just in case
  if (shld+hp < 100) return shldPower>healPower || hp >= 100-healPower? shield() : heal();

  var bon = shldPower-maxdmg < 3 && t < 700 ? lShld/2 : 0;
  var bon2 = t/100;
  if (gold>=cost(lFarm) && lShld+2 > lFarm && bon == 0 && !attacked) return upgrade("farm"); // farm first, but make sure it doesn't get too far ahead
  if (gold>=cost(lShld) && t>20 && (lShld<10+bon || lShld+5+bon2 < lFarm+bon) && t < 900) return upgrade("shield");
  if (gold>=cost(lFarm)) return upgrade("farm"); // try upgrading farming again, because shield upgrading can be picky
  if (gold>=cost(lHeal) && (lHeal<3)) return upgrade("heal"); // healing isn't that important

  if (shld<200 && attacked || shld<500 && t>20 && others.filter(c=>c.hp>=100).every(o=>o.hp+10 > hp+shld)) return shldPower>healPower || hp >= 100-healPower? shield() : heal();

  let hpdelta = attacked ? dmgTaken+shldPower : maxdmg
  if (shld<lShld*60 && (1000-t)*(hpdelta) > shld+hp) return shield(); // we want to look impressive & terrifying
  if (hp<=100-healPower) return heal();

  return farm();
}

আপনি যখন প্লিংক ক্ষতি করতে এবং এখনও পুরো ক্রেডিট পেতে পারেন তখন কেন আক্রমণ মানকে আপগ্রেড করবেন?

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

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

বট-ডু-টু-ডাই -কে-চমত্কার রোধ করতে এবং বট -কে-সম্ভবত-মেক-দ্য-মেরিটকে অবাক করার জন্য গৌণ আপডেট।

নমুনা ফলাফল (1000 গেমের পরে শীর্ষ 5 কেটে দেওয়া হয়েছে)

VM2406:1629 Kill Assist: 39495.679
VM2406:1629 The Accountant: 29990.267
VM2406:1629 Kill Stealer: 23530.153
VM2406:1629 Unkillable: 12722.604
VM2406:1629 captFarmer: 12232.466

— Draco18s
সূত্র

অপেক্ষা করুন, ক্যাপ্টেন ফার্মার কী বিশ্বে 14 কে সোনা পাবেন?

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

এটির একটি:runGame(1) results: [...] captFarmer: 13768

— Draco18s

এটি বেশ অপ্রত্যাশিতভাবে উচ্চতর ... এটি আমার পরীক্ষাগুলিতে প্রায় 10 কে প্রায় হয়

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

* শ্রুগ * কোন ধারণা নেই। আমি সমস্ত কিছু পরিষ্কারের জন্য বীমা করার জন্য একটি স্বয়ংক্রিয় গিস্ট আপডেট করব।

— Draco18s

সময়সীমা শেষ হওয়ার পরে আমার প্রিয় বট।

— রাত

7

Undyable বট (v3)

function undyableBot(me, others, storage){    

    if(me.hp < 100 - (me.levels.heal + 5)*2){
        return heal()
    }else{
        if(me.levels.heal < 10 && cost(me.levels.heal) / 2 < cost(me.levels.farm)){
            if(me.gold >= cost(me.levels.heal)){
                return upgrade("heal")
            }else{
                return farm()
            }
        }else{
            if(me.gold >= cost(me.levels.farm)){
                return upgrade("farm")
            }else{
                return farm()
            }
        }        
    }   
}

— লুইস ফিলিপে দে জেসুস মুনোজ
সূত্র

আমার কিছু মনে করবেন না ... আমি এই ধার নিতে যাচ্ছি।

— ড্রাকো 18

6

PatientStrategistBot

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

বর্তমানে এটি সঠিকভাবে কাজ করছে বলে মনে হয় না কারণ এটি হয় খেলার শুরুতে হত্যাকান্ডের দল দ্বারা হত্যা করা হয়েছিল বা এর আক্রমণাত্মক মোডে কোথাও আটকে গেছে।

এটি আমার প্রথম জেএস কোড হওয়ায় খুব খুশি, সুতরাং ... (আমি এখান থেকে কোড স্নিপেটগুলি চুরি করেছি এবং এর ফলে জেএসের সমস্ত বেসিক সিনট্যাক্সের গুগল করার চেয়ে দ্রুততর কারণ রয়েছে)

function PatientStratgistBot(me, others, storage) {

    //set up some stuff in first turn
    if (turn() == 1) {
    storage.selfWorth = 0;
    storage.attackMode = false;
    storage.expectHP = 100;
    storage.expectShield = 0;
    storage.shieldTarget = 0;
    storage.targetUid = "None";
    storage.attackRounds = 0;
    storage.targetStartHP = 100;

        return upgrade("farm");
    }

    let farmPower = me.levels.farm * 2 + 5;

    //defensive Actions

    var maxAtk = Math.max(...others.map(o => o.attack));

    storage.shieldTarget = Math.ceil(maxAtk * 1.25 / 1.5) + 1;

    if (me.levels.shield < storage.shieldTarget && me.gold >= cost(me.levels.shield) && me.levels.shield < me.levels.farm)
        return upgrade("shield");

    if (turn() >= 7 && me.shield < 10 && me.levels.shield * 1.5 >= me.levels.heal) return shield();

    if (turn() >= 15 && me.shield < 15 && me.levels.shield * 1.5 >= me.levels.heal) return shield();

    if (turn() >= 30 && me.shield < 20 && me.levels.shield * 1.5 >= me.levels.heal) return shield();

    //attack mode
    // check if there any targets worth to go for

    function findTarget(potentialTargets, baseR){
    var targetUID = "None";
    var best = 0;
    for( var i = 0; i < potentialTargets.length; i++) {
        //We upgrade to attack lvl12, so 20 dmg; assume an enemy can heal/shield up to 15 per round
        var killRounds = Math.ceil(potentialTargets[i].hp / 5)
        var gain = potentialTargets[i].worth / ( 2 * ( killRounds + baseR) )
        //console.log(me, turn(), potentialTargets[i], killRounds, baseR, gain, farmPower)
        if (gain > farmPower * ( killRounds + baseR ) && gain > best)
            targetUID = potentialTargets[i].uid;
            storage.targetStartHP =  potentialTargets[i].hp;
    }
    return targetUID;
    }


    if (turn() >= 600) {


    //check if a current target is dead
    const uids = others.map(x=>x.uid);
        if(storage.targetUid != "None" && !uids.includes(storage.targetUid)) {
        storage.targetUid = "None";
        storage.attackMode = false;
        storage.attackRounds = 0;
    }


    // check if we are doing enough damage to current target
    if (storage.targetUid != "None" && storage.attackRounds >= 3) {

        var deltaHP = storage.targetStartHP - others[storage.targetUid].hp

        if (deltaHP / storage.attackRounds < 5) {
            storage.targetUid = "None";
            storage.attackMode = false;
            storage.attackRounds = 0;

        }

    }

    var investCost = 0
    for( var i = me.levels.attack; i < 12; i++) investCost += cost(i);

    if (storage.attackMode == true && me.gold >= investCost && me.levels.attack < 12) return upgrade("attack");

    if (storage.attackMode == false) {
        baseRounds = investCost / farmPower * 1.2; //overestimation with the heal level we should have at this point

        if (findTarget(others, baseRounds) != "None")
            storage.attackMode = true;

        var betterThanMe = others.filter(o => o.worth >= storage.selfWorth);

        if (betterThanMe.length > 0)
            storage.attackMode = true;

        //storage.attackMode = true;


    }

    }

    if (storage.attackMode == true && me.levels.attack == 12) {

    if (storage.targetUid == "None") {

        var target = findTarget(others, 0)
        storage.targetUid = target;
        storage.attackRounds = 0;
        return attack(target);

    }

    return attack(storage.targetUid)

    }



    //otherwise farm

    if (me.hp < 50) {
    storage.expectHP += 5 + me.levels.heal;
        return heal();
    }

    if (me.gold >= cost(me.levels.farm) && storage.attackMode == false)
        return upgrade("farm");

    //upgrade heal, so we can farm more, but increase farm ability faster
    if (me.levels.farm > 5 && me.levels.heal < 10 && me.gold >= 2*cost(me.levels.heal))
        return upgrade("heal");


   //be opportunistic - check if killing someone is more profitable than farming
    killable = others.filter(o => o.hp < me.levels.attack * 1.25 + 5 && o.worth / 2 > farmPower);
    if (killable.length > 0){
    //ideally check for the most worth target here
        return attack(killable[0].uid);
    }

    storage.expectHP -= 2;
    storage.selfWorth += farmPower;
    return farm();

}

— Nicolai
সূত্র

6

সুইজর্লণ্ড

function switzerland(self,others,storage){
    let turnsLeft=999-turn()
    let lowestHpBots=others.sort((a,b)=>a.hp-b.hp)
    if(!storage.worth){
        storage.worth=0
        storage.prevGold=25
    }else if(self.gold>storage.prevGold){
        storage.worth+=self.gold-storage.prevGold
    }
    if(others.length===1&&storage.worth>others[0].worth){
        //stun lock the other bot if there are only 2 left and I can win
        return stun(others[0].uid)
    }else if(self.hp<=(95-self.levels.heal)){
        return heal()
    }else if(lowestHpBots[0]&&lowestHpBots[0].hp<20&&lowestHpBots[0].worth/2>2*self.levels.farm+5&&self.hp+self.shield>=110){
        //kill assist
        return attack(lowestHpBots[0].uid)
    } else if(self.shield<=50||self.shield<=5500/others.length&&self.shield<=1200&&turn()>=20||lowestHpBots[1]&&lowestHpBots[1].hp>self.hp+self.shield){
        return shield()
    }else if(self.gold>=cost(self.levels.shield)&&self.levels.shield<=8){
        return upgrade("shield")
    } else if(self.gold>=cost(self.levels.farm)&&(turnsLeft+1)*(2*(self.levels.farm)+5)<turnsLeft*(2*(self.levels.farm+1)+5)){
        return upgrade("farm")
    } else if(self.gold>=cost(self.levels.heal)&&(turnsLeft+1)/(self.levels.heal+5)*(2*self.levels.farm+5)<turnsLeft/(self.levels.heal+6)*(2*self.levels.farm+5)&&self.levels.heal<=2){
        return upgrade("heal")
    }else{
        return farm()
    }
}

নামের পরামর্শগুলির মত, এই বট হয় ~~নিরপেক্ষ~~ বেশিরভাগই নিরপেক্ষ (বর্তমানে এটা সাহায্য করে হত্যা বট যে মারা যাচ্ছি) এবং মাত্র খামার এবং হিলস, ধীরে ধীরে তার সোনা তৈরী ( ~~শুধু সুইজারল্যান্ড মত~~ )

— SuperStormer
সূত্র

6

দ্য বট দ্যাট ফার্মস, অ্যাটাকস, শিল্ডস এবং হিল হিলস কিন্তু কখনও স্টানস নয়

^{(সংক্ষিপ্ত নাম টিবিটিএফএএসএইএইচবিএনএস , টিবিটিটিজিসিবিসিবিএ- তে ভুল হওয়ার দরকার নেই )}

function TBTFASAEHBNS(me, others, storage) {
    this.getLevel = function (type) {
        return (typeof me.levels[type] === 'undefined' ? 0 : me.levels[type]);
    };

    this.getPower = function (type, level) {
        if (typeof level === 'undefined') level = this.getLevel(type);
        if (type === 'heal') return level + 5;
        if (type === 'attack') return (level * 1.25) + 5;
        if (type === 'shield') return (level * 1.5) + 5;
        if (type === 'farm') return (level * 2) + 5;
    };

    this.canUpgrade = function (type) {
        return myGold >= cost(this.getLevel(type));
    };

    this.farmOrUpgradeFarm = function () {
        if (this.canUpgrade('farm')) return upgrade('farm');
        if (myHp < 3) return heal();
        return farm();
    };

    let currentTurn = turn(),
        myGold = me.gold,
        myHp = me.hp,
        myShield = me.shield,
        myTotalHp = myHp + myShield,
        myHealPower = this.getPower('heal'),
        myShieldPower = this.getPower('shield'),
        myAttackPower = this.getPower('attack'),
        myFarmPower = this.getPower('farm'),
        topAttackPower = 0,
        attackOptions1 = [],
        attackOptions3 = [],
        attackOptions2 = [],
        finalTurns = 980;

    if (currentTurn === 1) {
        storage.othersInfo = {};
    }

    others.sort((a, b) => b.attack - a.attack);
    for (let i = 0; i < others.length; i++) {
        let other = others[i];

        if (i < 3) topAttackPower += this.getPower('attack', other.attack);

        if (other.worth > myFarmPower) {
            if (other.hp <= myAttackPower) {
                attackOptions1.push(other);
            } else {
                if (typeof storage.othersInfo[other.uid] !== 'undefined') {
                    let otherHpChange = storage.othersInfo[other.uid].hp - other.hp;

                    if (other.hp - otherHpChange <= 0) {
                        attackOptions2.push(other);
                    } else if (other.hp - (otherHpChange * 3) <= 0) {
                        attackOptions3.push(other);
                    }
                }
            }
        }

        storage.othersInfo[other.uid] = {hp: other.hp};
    }

    if (myTotalHp < (topAttackPower * 7) + 5) return shield();
    if (currentTurn <= 10) return this.farmOrUpgradeFarm();

    if (attackOptions1.length > 0) {
        attackOptions1.sort((a, b) => b.worth - a.worth);
        return attack(attackOptions1[0].uid);
    } else if (attackOptions2.length > 0) {
        attackOptions2.sort((a, b) => b.worth - a.worth);
        return attack(attackOptions2[0].uid);
    } else if (attackOptions3.length > 0) {
        attackOptions3.sort((a, b) => b.worth - a.worth);
        return attack(attackOptions3[0].uid);
    }

    if (currentTurn <= 20) return this.farmOrUpgradeFarm();
    if (currentTurn < finalTurns && myShieldPower < topAttackPower / 2 && Math.random() * 15 < 1 && this.canUpgrade('shield')) return upgrade('shield');
    if (currentTurn < finalTurns && this.canUpgrade('farm')) return upgrade('farm');
    if (currentTurn < finalTurns && myHealPower < 10 && this.canUpgrade('heal')) return upgrade('heal');
    if (myHp < 3) return heal();
    return farm();
}

এই বটটি মূলত:

শুরুতে চাষাবাদে গড়ে তোলে
যখন প্রয়োজন হয় তখন নিজেকে রক্ষা করে
যখন এটি হত্যা করতে পারে বা যখন মনে করে যে কাউকে হত্যা করার সুযোগ রয়েছে তখন আক্রমণ করে
এখানে এবং পরে আপগ্রেড
বাকি সময় কৃষিকাজ
কখনই স্তব্ধ হয় না

সম্পাদনা 1: প্রচুর গেমসের সাথে পরীক্ষার ভিত্তিতে একটি সমস্যা স্থির করে এবং বোটে কিছু ছোট জিনিস উন্নত করে।

সম্পাদনা 2: কমান্ড শিল্ড আপগ্রেড।

— Night2
সূত্র

2

নামটি দেখামাত্রই আমি জানতাম এটি আপনার বট হবে (:

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

দীর্ঘ নামগুলি নিয়ে দুঃখিত, তবে আমি এতে আসক্ত!

— রাত 2

1

হতে পারে এটি একটি ভাল বটের লক্ষণ ... আমার পরীক্ষাগুলি দেখায় এটি 5 তম স্থানে রয়েছে

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

5

SniperBot

এই বোট কেবল তখনই কার্যকর হবে যদি কেউ নিয়মিতভাবে আক্রমণ করে এমন বট যুক্ত করা শুরু করে। স্মার্টফর্মার আমার বর্তমানের অনুকূলিত সমাধান

এক শট পেতে পারে যদি নিরাময়
30 বছরের কম বয়সী যদি নিরাময় করে
বট আক্রমণ করে যদি তা বেছে নিতে পারে এবং কৃষিকাজের চেয়ে বেশি অর্থ উপার্জন করতে পারে
সাশ্রয়ী হলে খামার আপগ্রেড
80 টিরও কম বয়সী স্বাস্থ্যের উন্নতি করা এবং এটি সামর্থ্য
খামারে

শকুনদের আক্রমণ দরকার না

function sniperBot(me, others){
    if(me.hp < 30) return heal();
    for(var i = 0; i < others.length; i++)if(others[i].attack > me.hp)return heal();
    var target = -1;
    var targetWorth = me.levels.farm * 2 + 5;
    for(var i = 0; i < others.length; i++) {
        if (others[i].hp <= 1.25 * me.levels.attack + 5 && others[i].worth / 2 > targetWorth) {
            target= others[i].uid;
            targetWorth = others[i].worth / 2;
        }
    }
    if(target!=-1) return attack(target);
    if(me.gold >= cost(me.levels.farm)) return upgrade("farm");
    if(me.hp < 50 && me.gold >= cost(me.levels.heal)) return upgrade("heal");
    return farm();
}

— B0RDERS
সূত্র

intরেখায় অপ্রত্যাশিত শনাক্তকারী ( ) ২।

— Draco18s

হওয়া উচিত me.hp?

— mbomb007

দুঃখিত। জাভাস্ক্রিপ্ট নতুন। সহায়তার জন্য ধন্যবাদ

— B0RDERS

তোমার if(me.hp <30 && ...)একজন কিম্ভুতকিমাকার স্তর প্রয়োজন কারণে শুধুমাত্র প্রথম দফা সরলীকৃত যেতে পারে এটা (65 Lvl) ব্যাপার জন্য আরোগ্য

— Veskah

@ ওয়েশকাঃ এটি উল্লেখ করার জন্য ধন্যবাদ।

— নূন্যতম

5

BullyDozerBot

function BullyDozerBot(me, others, storage){
    if(me.gold >= cost(me.levels.attack) && (storage.bullyTarget && storage.bullyTarget.hp < 500)) {
        return upgrade("attack");
    }
    if(storage.bullyTarget==null){
        storage.bullyTarget=others.sort((a,b) => a.hp - b.hp)[0];
    }
    potential_victim = others.find( bot => bot.hp <= me.levels.attack * 1.25 + 5 );
    if (potential_victim) {
        return attack(potential_victim.uid);
    }
    var targetlives = false;
    for(var i = 0; i < others.length; i++) {
        if (others[i] == storage.bullyTarget) {
            targetlives = true;
            break;
        }
    }
    if(!targetlives){
        storage.bullyTarget=others.sort((a,b) => a.hp - b.hp)[0];
    }
    if(storage.bullyTarget.hp >= 500) {
        if(me.gold >= cost(me.levels.farm)) {
            return upgrade("farm");
        }
        for(var i = 0; i < others.length; i++){
          if(others[i].attack*1.25+10 > me.hp){
            return heal();
          }
        }
        return farm();
    }
    return attack(storage.bullyTarget.uid);
}

বুলিবট এবং কিছু অন্যান্য বিটের ম্যাসআপ। আশাবাদীর একটি সংক্ষিপ্ত এবং মধুর সুযোগসুষ্ট আক্রমণাত্মক আক্রমণ ছিল যা আমি ইঙ্গিত করেছিলাম (যদিও অন্যান্য বটগুলিও একই রকম গণনা করে)।

লক্ষ্যটিকে হতবাক করার পরিবর্তে তা তাদের মিষ্টি, মিষ্টি লুটের জন্য হত্যা করে । এটি ধর্ষণ করার জন্য পালের দুর্বলতমদেরও লক্ষ্য করে, তবে দুর্বলতম টার্গেটের এইচপি খুব বেশি হলে এটি হাল ছেড়ে দেবে এবং কেবল কৃষিকাজে চলে যাবে।

— Draco18s
সূত্র

আপনি নিজেকে মৃত্যুর দিকে চালিত করছেন। আমার সম্পাদনাটি গ্রহণ করুন :)

— B0RDERS

1

@ অ্যান্ড্রুবাডারস হা, এটি সম্পর্কে ভাবেনি। ধন্যবাদ।

— Draco18s

এই বটটি দুর্দান্ত ছিল যতক্ষণ না those প্রোটেক্টর বটগুলি চারদিকে আসে।

— বি0আরডিআরস

@ বি0আরডিআরএস শিল্ড খুব জোরালো, যদিও সময় নষ্ট হয়।

— Draco18s

5

FizzBuzz

function FizzBuzz(me, others, storage) {
    if (!storage.target) storage.target = others[0].uid;
    const uids = others.map(x=>x.uid);
    if(!uids.includes(storage.target) || (turn() % 30 === 0 
        && others[uids.indexOf(storage.target)].hp>30))
        storage.target = others[0].uid;

    if (cost(me.levels.farm) < me.gold) return upgrade("farm");
    if (turn() % 15 === 0) return heal();
    if (turn() % 3 === 0) return farm();
    if (turn() % 5 === 0) return heal();

    if (cost(me.levels.attack) < me.gold) return upgrade("attack");
    return attack(storage.target);
}

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

~~অসাধারণভাবে অসম্পূর্ণভাবে সম্পাদন করে।~~ কিছু মনে করবেন না, নিয়ামক আপডেট করেছেন, এখন সর্বদা প্যাকের মাঝখানে থাকে বলে মনে হয়।

— রিনের ফুরিয়ার রূপান্তর
সূত্র

আমি এই ধারণাটি পছন্দ করি। বর্তমান পরিস্থিতি নির্বিশেষে, এটি তার নিজস্ব গতিতে ধরে রাখছে।

— নেস

5

bullyBot

function bullyBot(me, others, storage){
    if(turn()==1){return farm();}
    if(storage.bullyTarget==null){storage.bullyTarget=others[0].uid;}

    var targetlives = false;
    for(var i = 0; i < others.length; i++) {
        if (others[i].uid == storage.bullyTarget) {
            targetlives = true;
            break;
        }
    }
    if(!targetlives){storage.bullyTarget = others[0].uid;}

    return stun(storage.bullyTarget);
}

এটি অনলাইন চেষ্টা করুন!

জিততে পারে না তবে তার লক্ষ্যটিও না হয় তা নিশ্চিত করার জন্য অবশ্যই তার সবচেয়ে সুন্দর চেষ্টা করবে। বুলিবট প্রথম টার্নেও খামার করে যাতে বাইরের প্রভাব না থাকলে সে তার লক্ষ্যটি 5-0 থেকে পরাজিত করবে বা তাদের 5-5 করে বেঁধে দেবে।

— Veskah
সূত্র

5

JustFarm

আমি ভেবেছিলাম আমি সহজ শুরু করব।

function justFarm(me, others){
    return farm();
}

— নামবিহীন
সূত্র

13

এই বট চাষের 2HP ব্যয়ের কারণে আত্মহত্যা করবে।

— ড্রাকো 18 ই

@ ড্রাকো 18 যদিও বটের সংখ্যার উপর নির্ভর করে রাউন্ডটি এর আগে শেষ হতে পারে

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

1

প্রযুক্তিগতভাবে সত্য হলেও , 50 টি রাউন্ড টাইমার খুব ছোট যখন ডিফল্ট শেষ সময় 1000 হয়

— ড্রাকো 18 ই

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

— অজ্ঞাতনামা

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

— হিল

4

স্ক্যাভেনজারবট (ভি 2)

বুঝতে পেরেছিলাম এটি আগে কোনও মাতালকারীর মতো ছিল না। নতুন কৌশলটি অপেক্ষা করতে থাকে যতক্ষণ না এটি অন্য বটকে হত্যা করতে পারে। যদি কাউকে হত্যা করা না যায় তবে এটি বসে এবং andাল তৈরি করে।

function scavengerBot(me, others) {
    if (me.shield < (me.levels.shield * 1.5 + 5)) {
        return shield();
    }
    var currentAttack = 1.25 * me.levels.attack + 5;
    var hasVictim = false;
    var victimUid = 0;
    var maxWorth = 0;
    for (var i = 0; i < others.length; i++) {
        var hp = others[i].hp;
        var worth = others[i].worth;
        if (hp <= currentAttack && worth > maxWorth) {
            hasVictim = true;
            victimUid = others[i].uid;
            maxWorth = worth;
        }
    }

    if (hasVictim) {
        return attack(victimUid);
    }

    if (me.gold >= cost(me.levels.attack)) {
        return upgrade("attack");
    }

    if (me.gold >= cost(me.levels.shield)) {
        return upgrade("shield");
    }
    return shield();
}

— reffu
সূত্র

1

me.levels.attacl?

— ড্রাকো 18 ই

ভাল ক্যাচ, ফিক্সড

— রেফু

4

মনমরা

function Moody(me, others, storage) {
    health = me.hp + me.shield;
    damage = storage.previous_health - health;
    storage.previous_health = health;
    if( damage > 2 ) {
        storage.fear = 2;
    }
    if( storage.fear ) {
        storage.fear -= 1;
        if( me.gold >= cost(me.levels.heal) )
            return upgrade("heal");
        return heal();
    }
    if ( me.hp <= 50 ) {
        return heal();
    }
    if (cost(me.levels.farm) < 0.15 * (1000 - turn())) {
        if( me.gold >= cost(me.levels.farm) )
            return upgrade("farm");
        if( me.gold >= cost(me.levels.heal) )
            return upgrade("heal");
        return farm();
    }
    rich_bots = others.sort( (x,y) => y.worth - x.worth );
    richest_enemy = rich_bots[0];
    if (richest_enemy.hp >= storage.target_hp) {
        storage.anger = true;
    }
    storage.target_hp = NaN;
    if (storage.anger) {
        if( me.gold >= cost(me.levels.attack) ) {
            storage.anger = 0;
            return upgrade("attack");
        }
        return farm();
    }
    storage.target_hp = richest_enemy.hp;   
    return attack(richest_enemy.uid);   
}

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

— histocrat
সূত্র

4

ডাকাত

function Bandit(me, others, storage) {
    // stuff we need
    const epsilon = 0.3; // really high epsilon
    function argmax(xs) {
        var max = 0;
        var argmax = 0;
        for (var i=0; i<xs.length; i++) {
            if (xs[i]>max) {
                max = xs[i];
                argmax = i;
            }
        }
        return argmax;
    }
    function base3ToActionSeries(strategy) {
        const actions = [shield(), farm(), heal()];
        var idxs = []
        var strategy_cut = strategy;
        for (var i = 81; i >= 1; i /= 3) {
            if (strategy_cut >= 2 * i) {idxs.push(2); strategy_cut -= 2*i}
            else if (strategy_cut >= i) {idxs.push(1); strategy_cut -= i}
            else idxs.push(0);
        }
        return idxs.map(idx => actions[idx]);
    }

    // actual logic starts here
    // current strategy and info to calculate reward
    if (!storage.prior)
        storage.prior = [0,0.03325,0,0.0361,0.0361,0.2372,0,0.2372,0,0.00035,0.0361,0.23555,0.01305,0.0361,0.5798,0.23555,0.62065,0.23555,0,0.2372,0,0.20965,0.5841,0.2372,0,0.21905,0,0.0361,0.0361,0.2081,0.0361,0.0361,0.01455,0.000350,0.62065,0.205,0.000350,0.0361,0.3708,0.0361,0.0323,1.018050,0.5798,0.04495,0.5798,0.23555,0.62065,0.23555,0.62065,1.06395,0.62065,0.23555,0.62065,0.23555,0,0.2372,0,0.2372,0.5841,0.2372,0,0.2372,0,0.23555,0.62065,0.13775,0.5798,1.0257,0.5798,0.23555,0.62065,0.23555,0,0.2339,0,0.2372,0.5841,0.2339,0,0.2372,0,0.0342,0.0361,0.2372,0.03515,0.03325,0.6228,0.2372,0.5841,0.2372,0.0361,0.0130599,0.62065,0.03515,0.0361,1.0665,0.62065,0.24050,0.62065,0.23555,0.51465,0.2372,0.6228,1.0257,0.6228,0.2372,0.5841,0.2372,0.0361,0.0361,0.58195,0.0361,0.0313596,1.0614,0.58195,1.02315,0.58195,0.0342,0.0361,1.0206,0.02255,0.0183,0.02595,1.0206,1.5526,1.0206,0.58195,1.02315,0.58195,0.02765,0.0251,1.0614,0.0007,0.02085,0.3088,0.2372,0.5841,0.2273,0.6185,0.02255,0.6228,0.2372,0.5841,0.2372,0.62065,1.06395,0.62065,1.0665,0.0917,1.0665,0.62065,0,0.62065,0.2372,0.5841,0.2372,0.6228,1.0257,0.6228,0.2372,0.5841,0.2372,0,0.2372,0,0.23225,0.5841,0.2372,0,0.2372,0,0.23555,0.62065,0.23555,0.5798,1.0257,0.5798,0.23555,0.6142,0.23555,0,0.22235,0,0.2372,0.5841,0.2372,0,0.2372,0,0.23555,0,0.21905,0.62065,0.02255,0.62065,0.23555,0.61205,0.23555,0.5798,1.05885,0.5798,1.018050,0.03895,1.018050,0.5798,1.05885,0.5798,0.23555,0.62065,0.23555,0.62065,0.0361,0.62065,0.23555,0.62065,0.23555,0,0.2372,0,0.2372,0.3745,0.2372,0,0.2372,0,0.23555,0.62065,0.23555,0.5798,0.9452,0.5798,0.23555,0.5626,0.23555,0,0.2372,0,0.18175,0.5841,0.0138,0,0.2372,0]
    if (storage.lastScore == null)
        storage.lastScore = 0;
    if (storage.bestStrategy == null)
        storage.bestStrategy = argmax(storage.prior);

    if (cost(me.levels.heal) < me.gold) return upgrade("heal");
    if (cost(me.levels.farm) < me.gold) return upgrade("farm");

    // This barely explores and mostly exploits.
    if (turn() % 5 === 0) {
        // update
        const reward = me.gold/2 - storage.lastScore;
        // biased a bit towards later learned rewards
        storage.prior[storage.bestStrategy] += reward*0.01
        storage.prior[storage.bestStrategy] *= 100/101

        // explore
        if (Math.random() < epsilon) {
            storage.bestStrategy = Math.floor(Math.random()*243);
        }
        else { // exploit
            storage.bestStrategy = argmax(storage.prior);
        } 
        storage.lastScore = me.gold/2;
    }

    var action = base3ToActionSeries(storage.bestStrategy)[turn() % 5];
    return action;
}

একটি শক্তিবৃদ্ধি শেখার বট এ প্রথম প্রচেষ্টা। অনুসন্ধানের স্থানকে সংকুচিত করতে এখনই বিশুদ্ধরূপে প্রতিরক্ষামূলক। ফিজবুজ-এর একটি চৌকস স্পিনোফের বাছাই করুন - এটি পাঁচটি ক্রিয়াটি নির্দিষ্ট ওপরে এবং তার উপরে পুনরাবৃত্তি করে; পাঁচটি ক্রিয়া যা আরএল দ্বারা চয়ন করা হয়।

তবে এটি বেশিরভাগই আপাতত গণনার বাইরে রয়েছে - আমি কেবলমাত্র পাঁচটি প্রতিরক্ষামূলক ক্রিয়াগুলির সমস্ত 3 ^ 5 = 243 ক্রম উত্পাদিত করেছি যা নিজেকে বারবার পুনরাবৃত্তি করে এবং তাদের গড় স্কোরগুলি (200 দ্বারা বিভক্ত করে, গড় লাভের জন্য অর্জন করে) পাঁচটি পালা) storage.priorঅ্যারেতে 100 টিরও বেশি পুনরাবৃত্তি । তারপরে, গেমের সময়, এটি সেই স্কোর তালিকাগুলি আপডেট করার জন্য একটি অ্যাপসিলন-লোভী পদ্ধতির প্রয়োগ করে যাতে এটি আরও ভবিষ্যতের প্রমাণ হয়। (এপসিলন = ০.০ ব্যবহার করে এপসিলন = ০.১ এর চেয়ে আরও ভাল কিছু করা হয়েছে তাই আমি এটি ঠিক রেখেছি))

এটি ঠিক আছে, নিয়মিত স্কেভেনগারবট এবং অপটিমিসিস্টের মধ্যে স্থাপন করে। আমি বর্তমানে বাস্তব গেমগুলি সম্পর্কে আরও কিছু প্রশিক্ষণ নিচ্ছি এবং কৌশলটি ফ্রেম করার আরও ভাল উপায়ের সন্ধান করছি, আমি এটি আরও উন্নত করতে পারি কিনা তা দেখার জন্য।

— রিনের ফুরিয়ার রূপান্তর
সূত্র

4

সুযোগ

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

সুতরাং এটি সরস হত্যার চুরি করে; প্রয়োজনীয় হলে নিরাময়; ফার্ম ক্রম আপগ্রেড, আক্রমণ এবং নিরাময়; এবং অন্যথায় খামার।

function Opportunist(me, others, storage) {

    // Initializing and keeping track of selfWorth
    if (turn() == 1) {
        storage.selfWorth = 0;
    }
    else if (storage.previousGold < me.gold) {
        storage.selfWorth += (me.gold - storage.previousGold);
    }
    storage.previousGold = me.gold;

    // Me stats
    var me_attack = 1.25 * me.levels.attack + 5;
    var me_heal = me.levels.heal + 5;

    // Look for the juiciest hunk of loot
    // If there are multiple of the highest worth, the last is chosen
    var choice = others[0].uid;
    var mostWorthy = -1;
    for (var i = 0; i < others.length; i++) {
        worth = others[i].worth
        if (others[i].hp <= me_attack && worth >= mostWorthy) {
            choice = others[i].uid;
            mostWorthy = worth;
        }
    }

    // Actions in order of priority
    // The juicy targets must be worth the action
    if (mostWorthy > (storage.selfWorth * 0.25) ) {
        return attack(choice);
    }
    else if (me.hp <= 100 - me_heal) {
        return heal()
    }
    else if (me.gold >= cost(me.levels.farm)) {
        return upgrade("farm");
    }
    else if (me.gold >= cost(me.levels.attack)) {
        return upgrade("attack");
    }
    else if (me.gold >= cost(me.levels.heal)) {
        return upgrade("heal");
    }
    else {
        return farm();
    }
}

— নেস
সূত্র

1

২ য় others

— তর্কটি

4

ScaredBot

এটি অন্যান্য বটগুলি আবিষ্কার করে:
- সর্বোচ্চ আক্রমণ সহ
- বেশিরভাগ সম্পদ এবং এইচপি নিজের আক্রমণ থেকে কম lower
যদি এর এইচপি + ঝাল পাওয়া যায় না এর চেয়ে কম হয় highest attack * (25% of bots)বা এটি নীচের প্রান্তের কাছাকাছি আসে HP + shieldতবে এটি thenাল দেয়
যদি এটি নিজের আক্রমণ থেকে কম ঝাল সহ একটি বট পেয়ে থাকে তবে এটি আক্রমণ করে।
যদি এর স্বাস্থ্য হয় < 50, এটি নিরাময় করে।
যদি এটি কোনও ieldাল, নিরাময় এবং খামার আপগ্রেড করতে পারে তবে এটি সর্বনিম্ন স্তরের সাথে আপগ্রেড করে
এটা খামার

function ScaredBot(me, others) {
    const my_attack = me.levels.attack * 1.25 + 5;
    const my_defense = me.hp + me.shield;

    var max_attack_val = 0;
    var min_hp_worth = 0;
    var min_hp_id = null;
    var hp_under_me = 0;
    for (var i=0; i<others.length; i++){
        if (others[i].hp < my_attack && others[i].worth > min_hp_worth){
            min_hp_id = others[i].uid;
            min_hp_worth = others[i].worth;
        }
        if (others[i].attack*1.25+5 > max_attack_val){
            max_attack_val = others[i].attack*1.25+5;
        }
        if (others[i].hp < my_defense && others[i].hp > 0){
            hp_under_me++;
        }
    }
    if (max_attack_val*0.25*others.length > my_defense || hp_under_me < 0.25*others.length){
        return shield();
    }
    else if (min_hp_id != null){
        return attack(min_hp_id);
    }
    else if (me.hp < 50){
        return heal();
    }
    else {
        var min_lvl = NaN;
        var min_name = null;
        const vals = [me.levels.heal, me.levels.shield, me.levels.farm];
        const names = ["heal", "shield", "farm"];
        for (var i=0; i<vals.length; i++){
            if (!(min_lvl < vals[i])){
                min_lvl = vals[i];
                min_name = names[i];
            }
        }
        if (me.gold > cost(min_lvl)){
            return upgrade(min_name);
        }
        return farm();
    }
}

ধারণাটি হ'ল দীর্ঘতম সম্ভব বেঁচে থাকুন এবং অন্যথায় আপগ্রেড করতে সক্ষম হওয়ার জন্য নিরাপদে এবং সস্তায় সোনার পাওয়ার চেষ্টা করুন।

আপগ্রেড অগ্রাধিকারগুলি সম্ভবত টিক করা উচিত, পাশাপাশি ঝাল করার বিষয়ে শর্ত নির্ধারণ করার সময়ও শর্তটি।

— user24343
সূত্র

3

SmartFarmer

খামার, খামার উন্নীতকরণ, স্বাস্থ্য কম হলে নিরাময় করে। সত্যিকারের আক্রমণাত্মক বটগুলি আগমন না হওয়া অবধি কৃষকরা অতিরিক্ত বিদ্যুৎপ্রাপ্ত বলে মনে হয়েছিল। এখন আমার বট মারা গেছে :-(

function smartFarmer(me, others){
    if(me.hp < 13) return heal();
    for(var i = 0; i < others.length; i++)if(others[i].attack * 1.25 + 5 > me.hp)return heal();
    if(me.gold >= cost(me.levels.farm)) return upgrade("farm");
    if(me.levels.heal < 9 && me.levels.farm > me.levels.heal + 7 && me.gold >= cost(me.levels.heal)) return upgrade("heal");
    return farm();
}

— B0RDERS
সূত্র

1

আমি (ম্যানুয়ালি) সর্বাধিক প্রাপ্তযোগ্য মূল্য কী এবং আমি যে সেরা নম্বরগুলি পেতে পারি তা দেখার জন্য একই কৌশলটি পরীক্ষা করছিলাম, নিরাময়ের সময় উন্নতি করার সময় আমি কিছুটা বিলম্বিত করেছিলাম (আমি সোনার> = ব্যয় * 2) এবং lvl10 নিরাময়ে যাচ্ছি ।

— নিকোলাই

দামের গুণকটি একটি ভাল ধারণা। আমি অনুরূপ কিছু যুক্ত। আপনি কী নম্বর পেয়েছেন তা জানতে আগ্রহী

— হব

3

শিকারীর শিঙ্গাধ্বনি

function Mort(me, others, storage) {
    if (me.hp <= 100 - (me.levels.heal + 5))
        return heal();
    actions = ["farm", "heal", "attack"].filter(action => cost(me.levels[action]) <= me.gold).map( action => [upgrade(action), 1000 - turn() - cost(me.levels[action]) ] )
    my_damage = me.levels.attack * 1.25 + 5;
    actions = actions.concat(others.map( bot => [ attack(bot.uid), (bot.worth/2)/Math.max(bot.hp/(my_damage-(bot.hp > my_damage ? 5 : 0)),1) ] ));
    actions.push( [farm(), (2 * me.levels.farm + 5)*(1-2/(me.levels.heal+5))] );
    return actions.sort( (x,y) => y[1] - x[1] )[0][0];
}

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

— histocrat
সূত্র

3

বন্ধুত্বপূর্ণ বট

function menShengFaDaCai(me, others) {
  // heal if needed
  const maxAttack = Math.max(...others.map(bot => bot.attack));
  const maxAttackCost = maxAttack * maxAttack + 5;
  const othersHp = others.map(bot => bot.hp).sort();
  const targetHp = othersHp[Math.ceil(othersHp.length / 2)];
  if (me.hp < 95 && me.hp < Math.max(maxAttackCost * 2, targetHp, 50)) return heal();

  // upgrade heal and farm if possible
  const { heal: healLevel, farm: farmLevel } = me.levels;
  const gain = (heal, farm) => ((5 + heal) / 2) * (2 * farm + 5) / ((5 + heal) / 2 + 1);
  const gain0 = gain(healLevel, farmLevel);
  const gainUpgradeHeal = gain(healLevel + 1, farmLevel);
  const gainUpgradeFarm = gain(healLevel, farmLevel + 1);
  const gainUpgradeHealPerGold = (gainUpgradeHeal - gain0) / cost(healLevel);
  const gainUpgradeFarmPerGold = (gainUpgradeFarm - gain0) / cost(farmLevel);
  const preferUpgradeHeal = gainUpgradeHealPerGold > gainUpgradeFarmPerGold;
  const mayOffer = type => me.gold >= cost(me.levels[type]);
  if (preferUpgradeHeal && mayOffer('heal')) return upgrade('heal');
  if (!preferUpgradeHeal && mayOffer('farm')) return upgrade('farm');

  // keep farming
  return farm();
}

others[0].hpএর hp + shieldপরিবর্তে hp...

— TSH
সূত্র

4

কেউ কি আমাকে ফাংশনটির নাম ইংরেজিতে অনুবাদ করতে সহায়তা করতে পারেন? ^ _ ^

— tsh

4

গুগল অনুবাদ অনুসারে, "闷声发大财" এর অর্থ "মাফলড" " খুব নিশ্চিত যে এটি আপনি চান না এবং বাস্তবেই এটি অন্য গুগল অনুবাদ একটি মহাকাব্য ব্যর্থ হয়েছে ... আমি আরও অনুসন্ধান করেছি এবং সমস্ত ফলাফলের মধ্যে উল্লেখ করা যেতে পারে যে এখানে একটিও ইংরেজি শব্দ ব্যবহার করা যায় নি, তাই এটি হিসাবে রাখাই ভাল হতে পারে এটি আসলে একটি চীনা প্রস্তুতি বলে মনে হয় যার সাধারণত অর্থ হল যে একজনকে নিঃশব্দে কাজ করা উচিত এবং ফলাফলগুলি নিজের পক্ষে কথা বলা উচিত এবং একটি traditionalতিহ্যগত দর্শনের কাছে পৌঁছে যায়। দুর্ভাগ্যক্রমে, আমি সরাসরি অনুবাদ করতে চাইনিজকে জানি না। : ডি

— এরিক আউটগল্ফার

1

স্থানীয় নেটিভ স্পিকার হিসাবে, এর অর্থ "নিঃশব্দে বিশাল ভাগ্য গড়ার" মতো কিছু: ভি এছাড়াও ইচ্ছাকৃতভাবে শান্ত থাকার, আক্ষরিক অর্থে "শব্দ coveringাকনা" বোঝায়

— রিনের ফুরিয়ার

1

নিনজা? UnderTheRadar? DontMindMe? AttentionDeflector?

— পিটার টেলর

3

হিসাবরক্ষক

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

function accountant(me, others, storage) {
    if (turn() == 1) {
        storage.lastHP = me.hp + me.shield;
        storage.hisAttack = 5;
        storage.timesAttacked = 0;
        storage.lastAttack = -1;
        storage.healths = [], storage.uids = [], storage.heals = [];
        for (var i = 0; i < others.length; i++) {
            storage.healths.push(others[i].hp);
            storage.uids.push(others[i].uid);
            storage.heals.push(5);
        }
    }
    storage.timesAttacked++;
    if (storage.lastHP == me.hp + me.shield) storage.timesAttacked = 0;
    else storage.hisAttack = storage.lastHP - me.hp - me.shield;
    storage.lastHP = me.hp + me.shield;
    var attacks = [];
    for (var i = 0; i < others.length; i++) if (others[i].uid != me.uid) attacks[i] = 1.25 * others[i].attack + 5;
    attacks.sort();
    for (var i = 0; i < others.length; i++) {
        storageIndex = storage.uids.indexOf(others[i].uid);
        if (storage.heals[storageIndex] < others[i].hp - storage.healths[storageIndex] + (others[i].uid == storage.lastAttack ? 1.25 * me.levels.attack + 5 : 0)) others[i].hp - storage.healths[storageIndex] + (others[i].uid == storage.lastAttack ? 1.25 * me.levels.attack + 5 : 0);
    }
    var maxProfitTurn = 2 * me.levels.farm + 5, victimID = -1, tempProfit;
    for (var i = 0; i < others.length; i++) {
        storageIndex = storage.uids.indexOf(others[i].uid);
        tempProfit = others[i].worth / 2 * (1.25 * me.levels.attack + 5 - storage.heals[storageIndex]) / others[i].hp;
        if (tempProfit > maxProfitTurn) {
            victimID = others[i].uid;
            maxProfitTurn = tempProfit;
        }
    }
    maxUrgentProfit = 0;
    for (var i = 0; i < others.length; i++) if (maxUrgentProfit < others[i].worth / 2 && others[i].hp <= attacks.slice(0, 4).reduce((a, b) => a + b) + 1.25 * me.levels.attack + 5) {
        maxUrgentProfit = others[i].worth / 2;
        victimID = others[i].uid;
    }
    if (maxUrgentProfit > 0) {
        storage.lastAttack = victimID;
        return attack(victimID);
    }
    storage.lastAttack = -1;
    if (storage.timesAttacked == 0) {
        if (me.levels.shield < 20 && me.gold >= cost(me.levels.shield)) return upgrade("shield");
        if (me.levels.heal < 5 && me.levels.shield >= me.levels.heal + 5 && me.gold >= cost(me.levels.heal)) return upgrade("heal");
        if (Math.random() < Math.pow((me.hp + me.shield) / 100, -2)) {
            storage.lastHP += 1.5 * me.levels.shield + 5;
            return shield();
        }
    }
    else {
        if (Math.random() < .5 || me.hp + me.shield - storage.hisAttack - attacks[0] <= 10) {
            storage.lastHP += 1.5 * me.levels.shield + 5;
            return shield();
        }
        if (me.levels.shield < 20 && me.gold >= cost(me.levels.shield)) return upgrade("shield");
        if (me.hp <= 2) {
            storage.lastHP += me.levels.shield + 5;
            return heal();
        }
        storage.lastHP -= 2;
        return farm();
    }
    if (me.gold >= cost(me.levels.farm)) return upgrade("farm");
    storage.lastAttack = victimID;
    if (victimID != -1) return attack(victimID);
    if (me.hp <= 2) {
        storage.lastHP += me.levels.shield + 5;
        return heal();
    }
    storage.lastHP -= 2;
    return farm();
}

— B0RDERS
সূত্র

3

reallyCommittedTurtle

function reallyCommittedTurtle(me, others, storage) {
    if( storage.previousHP ) {
        others.forEach ( o => {storage.deltaHP[o.uid] = o.hp - storage.previousHP[o.uid]; storage.previousHP[o.uid] = o.hp } );
    }
    else {
        storage.previousHP = {};
        storage.deltaHP = {};
        others.forEach ( o => storage.previousHP[o.uid] = o.hp );
    }
    if (turn() < 3)
        return upgrade("shield");
    if ( me.shield < 400 || others.find( o=> o.deltaHP < -2 ) )
        return shield();
    if (me.hp <= 95 - me.levels.heal) {
        if (me.gold >= cost(me.levels.heal))
            return upgrade("heal");
        return heal();
    }
    rich_bots = others.sort( (x,y) => y.worth - x.worth );
        potential_victim = rich_bots.find( bot => bot.hp + storage.deltaHP[bot.uid] <= me.levels.attack * 1.25 + 5 );
        if (potential_victim && potential_victim.worth/2 > me.levels.farm*2 + 5)
            return attack(potential_victim.uid);
    if (me.gold >= cost(me.levels.farm))
        return upgrade("farm");
    return farm();
}

এই যে জিনিসটা. এটি সত্যিই বিপজ্জনক হয়ে উঠেছে। কৃষিকাজ মোটেই আপনার মূল্য বাড়িয়ে তোলে, আপনাকে লক্ষ্য বানায়। সুতরাং যতক্ষণ না আপনি একটি বিশাল ieldাল তৈরি করেন এবং সমস্ত সহিংসতা নিহত না হওয়া অবধি ফার্ম করা নিরাপদ নয়। তারপরে আপনি নিজের শেল থেকে আপনার মাথা বের করে দিতে এবং চাষ শুরু করতে পারেন। বা হত্যা-সহায়তা। যাই হোক না কেন ভাল বেতন দেয়।

— histocrat
সূত্র

2

অভিভাবক

আমি একাধিক জমা দিতে পারি, তাই না?

ক্যাম্পবটের একটি কাঁটাচামচ। Ieldাল দেয় না, পরিবর্তে আক্রমণে মনোনিবেশ করে। ক্যাম্পবটের মতো এলোমেলোভাবে আঘাত না করে উচ্চতর আক্রমণাত্মক পরিসংখ্যান সহ খেলোয়াড়দের আক্রমণ করার জন্য অগ্রাধিকার দেখায়। নিরাময়ের পরিবর্তে এর চাষের উন্নতিতে ফোকাস।

function guardian(self,others,storage){
    if(!storage.victimBlacklist){
        storage.victimBlacklist=[]
    }
    let turnsLeft=999-turn()
    function findVictim(){
        let potentialVictims=others.filter(bot=>!storage.victimBlacklist.includes(bot.uid))
        if(potentialVictims.length>0){
            let victim=potentialVictims.reduce((el, em) => el.attack > em.attack ? el : em);
            storage.victimUid=victim.uid
            storage.victimPrevHp=victim.hp
            storage.prevMove="attack"
            return attack(victim.uid)
        }else{
            storage.prevMove="farm"
            return farm()
        }   
    }
    if(self.hp<=(95-self.levels.heal)){
        storage.prevMove="heal"
        return heal()
    } else if(self.gold>=cost(self.levels.attack)){
        storage.prevMove="upgrade"
        return upgrade("attack")
    } else if(self.gold>=cost(self.levels.farm)&&turnsLeft>100&&self.levels.heal<=1){
        storage.prevMove="upgrade"
        return upgrade("farm")
    } else if(!storage.victimUid){
        return findVictim()
    }else if(Object.values(others).map(bot=>bot.uid).includes(storage.victimUid)){
        let victimCurrHp=Object.values(others).filter(bot=>bot.uid==storage.victimUid)[0].hp
        if(storage.victimPrevHp<victimCurrHp&&storage.prevMove==="attack"){
            storage.victimBlacklist.push(storage.victimUid)
            storage.victimUid=undefined
            return findVictim()
        }else{  
            storage.victimPrevHp=victimCurrHp
            storage.prevMove="attack"
            return attack(storage.victimUid)
        }
    }else{
        storage.victimUid=undefined
        return findVictim()
    }
}

— নামবিহীন
সূত্র

আমার বট এলোমেলোভাবে আক্রমণ করতে পারে না ...

— সুপারস্টোরমার

আপনি যতবার চান ততবার পোস্ট করতে পারেন, আমার মনে হয় আরও

— মারিয়ার

@ সুপারস্টোরমার আমি বুঝতে পারি আপনার সম্পূর্ণরূপে এলোমেলো নয়, তবে:let victim=potentialVictims[Math.floor(Math.random()*potentialVictims.length)]

— বেনামে

তবে এটি প্রথমে ফিল্টারগুলি আক্রমণ করার জন্য উপযুক্ত নয়

— সুপারস্টোরমার

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

— বি0আরডিআরস

2

Rando

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

সুতরাং, তার সময় প্রায় 3/9 সময় এবং ফার্মের প্রায় 2/9 আক্রমণ করা উচিত। বাকিগুলি প্রায় 1/9 টি সম্ভাবনা রয়েছে যদি সে আপগ্রেড করতে সক্ষম হয়, বা নিরাময় / ieldালদান যদি মূল্যবান হয় তবে ইত্যাদি chance

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

function Rando(me, others, storage) {

    var rnum = Math.floor(Math.random() * 9);
    switch (rnum) {
        case 0:
            if (me.gold >= cost(me.levels.shield)) {
                return upgrade("shield");
            }
        case 1:
            if (me.hp >= 100 - (me.levels.heal + 5) && me.levels.shield >= me.levels.heal) {
                return shield();
            }
        case 2:
            if (me.hp < 100 - (me.levels.heal + 5)) {
                return heal();
            }
        case 3:
            if (me.gold >= cost(me.levels.farm)) {
                return upgrade("farm");
            }
        case 4:
            if (me.gold >= cost(me.levels.heal)) {
                return upgrade("heal");
            }
        case 5:
            if (me.hp > 2) {
                return farm();
            }
        case 6:
            // Beat down the leader!
            var currentLeader = others[0].uid;
            var leaderWorth = -1;
            for (var i = 0; i < others.length; i++) {
                worth = others[i].worth;
                if (worth > leaderWorth) {
                    currentLeader = others[i].uid;
                    leaderWorth = worth;
                }
            }
            return stun(currentLeader);
        case 7:
            if (me.gold >= cost(me.levels.attack)) {
                return upgrade("attack");
            }
        case 8:
            // Find the juiciest kill (if any), or attack the strongest
            var choice = others[0].uid;
            var choiceWorth = -1;
            var currentLeader = others[0].uid;
            var leaderWorth = -1;
            for (var i = 0; i < others.length; i++) {
                worth = others[i].worth
                if (worth > leaderWorth) {
                    currentLeader = others[i].uid;
                    leaderWorth = worth;
                }
                if (others[i].hp <= (1.25 * me.levels.attack + 5) && worth >= choiceWorth) {
                    choice = others[i].uid;
                    choiceWorth = worth;
                }
            }
            if (choice > -1) {
                return attack(choice);
            }
            else {

                return attack(currentLeader);
            }
        default:
            return false
    }
}

(আমি জানি "ডিফল্ট" অপ্রয়োজনীয়, তবে আমি মনে করি এটি দৃ rob় কোডের জন্য কোডিং অনুশীলন is

— নেস
সূত্র

2

"তার কেবল নিজের উপর বিশ্বাস রাখা দরকার" ... আমি এখনই অনেক হাসছি

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

2

বট কিল

function killBot(me, others, storage) {
    // If I lost health since my last check, shield.
    if (me.hp < storage.hp){
        storage.hp = me.hp;
        return shield();
    }

    storage.hp = me.hp;

    health = Math.min(...others.map(o => o.hp));
    // If I have the least health or can be one-shot, shield.
    if (others.some(o => o.attack * 1.25 + 5 >= me.hp + me.shield) || (health > me.hp + me.shield && health < 500)) return shield();

    // If I can kill someone, kill them!
    targets = others.filter(o => o.hp < me.attack);
    if (targets.length > 0){
        wealth = Math.max(...targets.map(o => o.worth));
        targets = targets.filter(o => o.worth == wealth);
        target = targets[Math.floor(Math.random()*targets.length)];
        return attack(targets[0].uid);
    }

    // If I have the money, upgrade shielding or attack
    if (me.levels.shield <= me.levels.attack){
        if (cost(me.levels.shield) < me.gold) return upgrade("shield");
    } else {
        if (cost(me.levels.attack) < me.gold) return upgrade("attack");
    }

    // Otherwise, attack the weakest!
    targets = others.filter(o => o.hp == health);
    // And if there's a tie, attack the wealthiest.
    wealth = Math.max(...targets.map(o => o.worth));
    targets = targets.filter(o => o.worth == wealth);
    target = targets[Math.floor(Math.random()*targets.length)];
    return attack(targets[0].uid);
}

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

— Spitemaster
সূত্র

3

নোট করুন যে o.attackআক্রমণ স্তর, এটির ক্ষতি নয়

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

2

ফার্মহেল বট

@ অজ্ঞাতনামা 'জাস্টফর্ম বট' থেকে ফোরকড

function farmhealBot(me, others, storage) {
  if (me.hp <= 95)
    return heal();
  else return farm();
}

— maninthecomputer
সূত্র

2

অবিনশ্বর

ড্র্যাকো 18 এর বটের একটি পরিবর্তন, ঝাল ব্যবহার করে (অন্যান্য বটগুলির বিরুদ্ধে আরও কার্যকর)

function indestructible(me){
    if (me.hp < 100) {
        return heal();
    } else if (me.shield < 15) {
        return shield();
    } else {
        if (me.gold >= cost(me.levels.shield)) {
            return upgrade("shield");
        } else if (me.gold >= cost(me.levels.farm)) {
            return upgrade("farm");
        } else {
            return farm();
        }
    }
}

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

সোনার যুদ্ধ কোথ

Unkillable

ThanosBot

কিল স্টিলার

ইকুয়ালাইজার

আশাবাদী

সহায়তা হত্যা

Undyable বট (v3)

PatientStrategistBot

সুইজর্লণ্ড

দ্য বট দ্যাট ফার্মস, অ্যাটাকস, শিল্ডস এবং হিল হিলস কিন্তু কখনও স্টানস নয়

SniperBot

BullyDozerBot

FizzBuzz

bullyBot

JustFarm

স্ক্যাভেনজারবট (ভি 2)

মনমরা

ডাকাত

সুযোগ

ScaredBot

SmartFarmer

শিকারীর শিঙ্গাধ্বনি

বন্ধুত্বপূর্ণ বট

হিসাবরক্ষক

reallyCommittedTurtle

অভিভাবক

Rando

বট কিল

ফার্মহেল বট

অবিনশ্বর