Pertempuran Emas KoTH

44

Tantangan ini telah berakhir. Untuk melihat skor akhir para pesaing, klik di sini

Dalam tantangan ini, setiap pengiriman adalah satu bot. Setiap bot harus merupakan fungsi Javascript. Bot akan berjuang untuk mendapatkan total nilai tertinggi dalam emas. Emas dapat diternakkan, atau diperoleh dari membunuh bot lain, dan digunakan untuk meningkatkan penyembuhan, serangan, perisai, dan pertanian.

Objektif:

Lebih dari sejumlah putaran yang berisi hingga 1000 putaran (berakhir ketika hanya satu bot yang tersisa), bot dengan nilai total tertinggi (jumlah semua emas yang diperoleh) adalah pemenangnya.

Ternyata:

Di setiap belokan, setiap bot yang hidup (> 0 HP) akan dijalankan sekali. Itu bisa mengembalikan gerakan, yang bisa menjadi salah satu dari yang berikut:

  • Sembuh: Mendapatkan kembali HP
  • Attack: Menghapus HP dari bot lain
  • Shield: Bertahan dari serangan selanjutnya
  • Stun: Melewati giliran bot lain
  • Peternakan: Menghasilkan emas dengan biaya HP
  • Tingkatkan: Buat gerakan tertentu lebih baik

Semua bot akan mengembalikan gerakan mereka sebelum ada yang dieksekusi, jadi setrum, sembuhkan, serang, perisai, dll. Tidak akan memengaruhi bot yang bergerak di kemudian hari pada giliran itu. Sebagai contoh, jika Bot A setrum Bot B, dan Bot B adalah setelah Bot A dalam urutan belokan, Bot B masih akan bergerak kemudian di belokan yang sama dan setrum akan terjadi pada belokan berikutnya.

Memerangi, Bertani, dan Meningkatkan:

Setiap bot memiliki HP maksimum 100, dan UID yang ditetapkan antara 0 dan 99. UID ini berubah setelah setiap putaran, dan bagaimana bot melacak satu sama lain.

Penyembuhan adalah salah satu langkah paling sederhana, menambahkan jumlah HP yang ditentukan oleh levelnya (mulai dari 5 HP). Bot tidak dapat menyembuhkan melebihi 100 HP.

Menyerang bot dengan UID-nya adalah langkah lain yang mungkin, dengan kerusakan dasar sebesar 5 HP pada level 0. Bot juga dapat dibuat terpana, melewatkan giliran berikutnya, yang juga menggunakan UID.

Bot memiliki perisai tambahan HP, yang tidak memiliki batas. Perisai ini HP akan menyerap kerusakan dari serangan langsung dari bot lain, dan ditambahkan dengan perisai. Pada level 0, perisai menambahkan 5 perisai HP.

Pertanian akan menghasilkan 5 emas pada level 0, dengan biaya 2 HP. 2 HP ini tidak dapat dilindungi. Satu-satunya penggunaan emas (di luar kemenangan) adalah untuk meningkatkan gerakan. Penyembuhan, serangan, dan perisai memiliki nilai dasar 5 HP, dan pertanian dimulai dari 5 emas. Setiap gerakan tersebut memiliki level individual, yang dimulai dari 0. Formula ini akan menentukan nilai dalam HP atau emas gerakan, di mana L adalah level:

  • Penyembuhan: L + 5
  • Menyerang: 1.25L + 5
  • Melindungi: 1.5L + 5
  • Pertanian: 2L + 5

Biaya untuk meningkatkan gerakan apa pun adalah sama untuk tingkat tertentu, dan ditentukan oleh 2.5L² + 2.5L + 10, di mana L adalah tingkat saat ini. Bot dapat menggunakan fungsi cost(currentLevel)sebagai jalan pintas untuk menentukan ini.

Bot dimulai dengan 25 emas, memungkinkan mereka untuk dengan cepat meningkatkan dua gerakan ke level 1, atau satu gerakan ke level 2. Emas awal ini tidak dihitung terhadap nilai total bot. Membunuh sebuah bot memberi Anda setengah dari total nilainya dalam emas, dibulatkan ke atas, dan jika dua bot membunuh yang lain dalam giliran yang sama, mereka berdua mendapatkan hadiah.

Input output:

Untuk berkomunikasi dengan pengontrol, nilai kembali fungsi digunakan untuk mengirim informasi bergerak. Salah satunya harus dikembalikan:

  • Menyembuhkan: heal()
  • Menyerang: attack(uid)
  • Melindungi: shield()
  • Setrum: stun(uid)
  • Tanah pertanian: farm()
  • Meningkatkan: upgrade("heal" / "attack" / "shield" / "farm")

Untuk melewati belokan (tidak melakukan apa-apa), tidak menghasilkan apa-apa, atau mengembalikan nilai palsu.

Untuk mendapatkan nomor belokan saat ini (mulai dari 1), gunakan turn().

Argumen fungsi Anda akan mencakup informasi tentang bot Anda, UID bot lain, dan penyimpanan antar-belokan. Argumen pertama adalah obyek dengan sifat sebagai berikut: uid, hp, gold, dan shield. Ini adalah salinan informasi bot Anda saat ini. Ada juga sebuah objek bersarang levels, dengan angka tingkat heal, attack, shield, dan farm.

Argumen kedua adalah susunan acak semua bot hidup selain bot Anda, yang diformat sebagai objek yang berisi properti uid, hp(plus perisai) worth,, dan attack(tingkat serangan). Argumen ketiga adalah objek kosong yang dapat digunakan untuk penyimpanan antar-giliran.

Contoh Bot:

Bot ini akan bertani hingga dapat meningkatkan serangannya ke level 5, lalu menyerang bot acak setiap belokan hingga mati (atau menang). Tidak terlalu efektif karena kurang penyembuhan / perisai.

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

Bot ini memiliki dua mode: ofensif dan defensif. Itu akan baik setrum bot acak atau sembuh ketika dalam mode defensif, dan itu akan baik menyerang atau melindungi ketika dalam mode ofensif. Itu akan berusaha untuk meningkatkan serangannya bila memungkinkan.

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

Aturan:

  • Standar Lubang terlarang
  • Bot mungkin tidak membaca, memodifikasi, atau menambahkan variabel apa pun di luar ruang lingkupnya, mungkin tidak mencoba untuk menipu, dan tidak dapat memanggil fungsi DOM yang ditentukan pengendali atau
  • Nilai pengembalian harus salah, atau salah satu dari fungsi keluaran di atas
  • Bot tidak boleh dirancang untuk menargetkan bot tertentu, tetapi dapat dirancang untuk memanfaatkan strategi umum
  • Bot tidak boleh menyerang diri mereka sendiri (ditemukan karena komentar oleh @Ness)
  • Bot harus cukup berbeda dari bot lain sehingga dapat dianggap entri yang terpisah
  • Teaming sekarang tidak diizinkan
  • Kontroler dapat ditemukan di sini
  • Ruang obrolan

Debugging Pengendali Baru:

Menggunakan file gold-battle-log.js, Anda dapat mengatur nilai debugproperti bot botDatake 0 (tidak ada penebangan), 1 (bergerak log), atau 2 (bergerak log, hp, emas, level, dll.)

Tantangan berakhir pada 1700 UTC pada hari Jumat, 9 Agustus

king-of-the-hill  javascript 
— Program Redwolf
sumber
4
Dibuat inti dengan semua bot. gist.github.com/Draco18s/2efbf95edcf98d6b1f264e26bbb669d1 Saya akan berusaha keras untuk memperbaruinya (tetapi jika bukan ini awal yang baik).
— Draco18s
4
Pengontrol pembaruan otomatis dengan bot termasuk: redwolfprograms.com/koth
— Redwolf Programs
4
Saya memberikan suara untuk menutup pertanyaan ini karena sudah de-facto tertutup untuk jawaban baru ("Tantangan ini telah berakhir. Untuk melihat skor akhir ...")
— pppery
3
@pppery, bisakah kau tidak? Saya akan baik-baik saja dengan jawaban yang tidak kompetitif, dan [closed]pada akhirnya cenderung membuat pemirsa biasa melewatkan membaca tantangan saya karena mereka; D menganggapnya berkualitas rendah atau di luar topik.
— Program Redwolf
5
@pppery Saya tidak pernah mendengar ada tantangan yang ditutup karena diselesaikan sampai hari ini, dan saya berpendapat bahwa pembatasan sosial yang ingin Anda lakukan tidak ada. Tidak perlu menutupnya, dan saya tidak ingin ditutup. Bagi saya, itu seperti menutup demi menutup, bukan untuk kebaikan situs. Jika seseorang ingin memposting jawaban untuk pertanyaan lama, mereka seharusnya bisa. Tidak ada catatan setelah aturan penantang serius yang mengatakan itu harus menjadi penantang serius ketika diposting; jawaban masih bisa menjadi pesaing serius untuk tantangan bahkan jika itu bukan pesaing untuk menang
— Redwolf Program

Jawaban:

16

Tidak bisa diraih

bercabang dari 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()
        }
    }
}

Mengingat biaya eksponensial dari peningkatan, mungkin juga meningkatkan pertanian jika kita tidak dapat meningkatkan penyembuhan, memungkinkan bot untuk mengumpulkan emas lebih efisien.

— Draco18s
sumber
Benar-benar menghancurkan kompetisi dalam ujian saya
— Program Redwolf
1
Saya merasa bot ini mungkin sedikit lebih kuat jika ifpernyataan pertama kali digunakan <=- saat ini tidak akan pernah pulih sepenuhnya.
— Scoots
@Scoots Tidak yakin seberapa penting itu, tetapi saya akan mengubahnya.
— Draco18s
2
@ Draco18s, saya yakin ini sangat kecil artinya - tetapi bukankah situs ini hanya tentang perbaikan kecil yang praktis tidak berarti? :)
— Scoots
@Soots Healing to max health tidak masalah banyak dalam tantangan ini karena tidak ada ancaman serangan nyata. Satu-satunya bot yang benar-benar ofensif adalah bullybot, dan Anda tidak bisa melakukan apa-apa tentang dia. Ini mungkin sebenarnya menurunkan kinerja untuk tetap sehat penuh.
— B0RDERS
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();
            }
        }
    }
}

Ada terlalu banyak bot, tidak cukup emas untuk berkeliling. Bot ini mengusulkan solusi.

Genosida, ya, tapi acak, tidak memihak, adil bagi kaya dan miskin.

Mereka memanggilnya orang gila.

ThanosBot menginginkan yang terbaik untuk komunitas bot, dan bersedia melakukan apa saja. Pada awalnya, ia akan meningkatkan serangannya, bertani dan menyembuhkan, agar lebih efisien mengumpulkan sumber daya dan memenangkan pertempuran. Secara progresif, ia akan mulai menyerang orang secara acak sambil masih mengumpulkan sumber daya, untuk pertempuran yang akan datang. Dia akan terus meningkatkan pasukannya, senjatanya, dan dirinya sendiri.

Setelah 50% dari populasi telah dieliminasi, bot yang lahir hanya akan mengetahui perut penuh dan langit cerah, ia akan pensiun ke kehidupan bertani, dan menyaksikan matahari terbit di alam semesta yang bersyukur. Dia akan menjadi benar-benar pasifis, hanya menyembuhkan dirinya sendiri dengan sup sayur dan bertani.

— Kaito Kid
sumber
6
Saya tergoda untuk mengganti nama "serang" menjadi "jepret"
— Redwolf Programs
11

Bunuh Stealer

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

Sekarang tidak hanya mencuri membunuh, tetapi mencuri mencuri membunuh juga!

Bot ini tidak melakukan banyak hal selain pertanian, dan ketika menyadari kemungkinan, bergabung dalam melakukan pukulan terakhir ke musuh yang sekarat, dan entah bagaimana berhasil menjadi sangat baik.

— dzaima
sumber
Ini berhasil karena semua bot yang terlibat dalam pukulan membunuh mendapatkan hadiah penuh.
— Draco18s
@ Draco18s Saya mengerti mengapa itu bisa baik, saya hanya tidak mengharapkan ide sederhana untuk mendapatkan rata-rata 2x skor bot terbaik berikutnya (pada saat membuatnya).
— dzaima
Hehe, itu adil. Saya harus mengunduh semua bot ketika saya bisa dan melihat apakah saya dapat menemukan solusi lain.
— Draco18s
9

Equalizer

Bot ini berupaya memulihkan perdamaian di komunitas bot. Dia tanpa henti menargetkan bot dengan serangan tertinggi, menyerah hanya jika penyembuhan bot lebih baik daripada serangannya sendiri. Begitu tidak ada bot dengan penyembuhan yang lebih buruk dari serangannya, ia akan pensiun ke kehidupan pertanian yang damai.

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();
}
— PEMBELI
sumber
8

Optimis

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

Anggaplah ia dapat menghabiskan 80% waktunya untuk bertani secara damai, jadi ia memulai dengan memaksimalkan pertanian, dan baru kemudian mulai memperhatikan keterampilan tempurnya. Tentunya tidak ada yang salah!

— histokrat
sumber
8

Bunuh Assist

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

Mengapa meningkatkan nilai serangan ketika Anda dapat melakukan plink damage dan masih mendapatkan kredit penuh?

Sekali lagi kembali untuk membonceng Kill Stealer. Saya dapat menyederhanakan beberapa blok kode di mana pernyataan selalu benar dan mengutak-atik sejumlah angka yang menghasilkan keuntungan besar atas yang asli.

Saya harus menyerahkannya ke @dzaima karena menyadari bahwa memukau lawan kaya yang kemungkinan akan terlibat dalam membantu pergantian sebelum pembunuhan terjadi cukup pintar. Salah satu (sangat) beberapa kali Stun()memiliki hasil penjumlahan positif. Sekali lagi saya dapat memperbaiki ide tersebut, karena mengetahui bahwa Kill Stealer akan menjalankan logika yang sama, Kill Assist mencari target "terbaik kedua" (dengan beberapa pertimbangan) dan malah mengejutkan mereka.

Pembaruan kecil untuk mencegah memesona bot-tentang-untuk-mati dan mencegah memesona bot-paling-kemungkinan-untuk-membuat-membunuh-.

Hasil sampel (terpotong 5 besar setelah 1000 pertandingan)

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
sumber
Tunggu, di dunia apa Kapten Petani mendapat 14k emas?
— Program Redwolf
Yang ini:runGame(1) results: [...] captFarmer: 13768
— Draco18s
Itu cukup tinggi ... biasanya sekitar
— 10rb
* shrugh * Tidak tahu. Saya akan melakukan pembaruan inti otomatis hanya untuk memastikan semuanya bersih.
— Draco18s
Bot favorit saya pada akhir tenggat waktu.
— Night2
7

Bot yang Tidak Dapat Diabaikan (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()
            }
        }        
    }   
}
— Luis felipe De jesus Munoz
sumber
Jangan pikirkan aku ... Aku akan meminjam ini.
— Draco18s
6

PatientStrategistBot

Saya mencoba menulis bot yang mulai membingkai dan membela sesuai kebutuhan dan kemudian beralih untuk membunuh bot bernilai tinggi lainnya di kemudian hari dalam permainan.

Saat ini ini tampaknya tidak berfungsi dengan baik karena baik dibunuh oleh sekelompok pembunuh-bots di awal permainan atau terjebak di suatu tempat dalam mode ofensifnya.

Masih cukup senang dengan ini menjadi kode JS pertama saya, jadi ... (Saya mencuri cuplikan kode dari sini & di sana karena itu lebih cepat daripada googling semua sintaks dasar JS)

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
sumber
6

Swiss

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

Seperti namanya, bot ini netral sebagian besar netral (sekarang membantu membunuh bot yang akan mati) dan hanya bertani dan menyembuhkan, perlahan-lahan membangun emasnya ( seperti swiss )

— SuperStormer
sumber
6

Bot Yang Bertani, Menyerang, Melindungi, Dan Bahkan Menyembuhkan Tapi Tidak Pernah Stun

(Nama pendek adalah TBTFASAEHBNS , jangan salah dengan TBTPTGCBCBA )

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

Bot ini pada dasarnya:

  • Membangun pertanian di awal
  • Membela diri saat dibutuhkan
  • Menyerang ketika itu bisa membunuh atau ketika dia berpikir ada kesempatan untuk membunuh seseorang
  • Upgrade di sini dan kemudian
  • Bertani sisa waktu
  • Tidak pernah setrum

Sunting 1: Memperbaiki masalah dan meningkatkan beberapa hal kecil di bot berdasarkan tes dengan banyak game.

Sunting 2: Peningkatan perisai yang dikurangi.

— Night2
sumber
2
Segera setelah saya melihat nama saya tahu itu akan menjadi bot Anda (:
— Program Redwolf
Saya minta maaf tentang nama-nama panjang, tapi saya kecanduan!
— Night2
1
Mungkin itu pertanda bot yang bagus ... tes saya menunjukkan itu di tempat ke-5
— Program Redwolf
5

SniperBot

Bot ini hanya akan efektif jika seseorang mulai menambahkan bot yang benar-benar menyerang secara teratur. SmartFarmer adalah solusi optimal saya saat ini

  1. menyembuhkan jika bisa mendapatkan satu tembakan
  2. sembuh jika di bawah 30
  3. menyerang bot jika bisa mengambilnya dan mendapatkan lebih banyak uang daripada bertani
  4. meningkatkan pertanian jika mampu
  5. meningkatkan penyembuhan jika berada di bawah 80 kesehatan dan mampu
  6. peternakan

burung nasar tidak perlu serangan

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();
}
— PEMBELI
sumber
Identifier tidak terduga ( int) pada baris 2. ReferenceError: kesehatan tidak ditentukan.
— Draco18s
Seharusnya me.hp?
— mbomb007
Maaf. baru mengenal javascript. terima kasih atas bantuannya
— B0RDERS
Anda if(me.hp <30 && ...)dapat disederhanakan menjadi hanya klausa pertama karena membutuhkan tingkat penyembuhan yang absurd untuk masalah (lvl 65)
— Veskah
@Veskah Terima kasih telah menunjukkannya. Itu adalah sisa dari saat min hp lebih tinggi
— B0RDERS
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);
}

Mashup dari BullyBot dan beberapa bit lainnya. Optimist memiliki serangan oportunistik singkat dan manis yang saya pikirkan (meskipun bot lain melakukan perhitungan yang sama).

Alih-alih menggertak target dengan memukau mereka, itu membunuh mereka karena jarahan mereka yang manis dan manis. Ini juga menargetkan yang terlemah dalam kawanan untuk digertak, tetapi itu akan menyerah dan hanya bertani jika HP target terlemah terlalu tinggi.

— Draco18s
sumber
Anda bertani sampai mati. Terima edit saya :)
— B0RDERS
1
@AndrewBorders Ha, bahkan tidak memikirkannya. Terima kasih.
— Draco18s
Bot ini hebat sampai bot pelindung itu muncul.
— B0RDERS
@ B0RDERS Shield sangat kuat, bahkan jika itu membuang waktu.
— 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);
}

Bot yang paling ofensif. Sangat kesal dengan kenyataan bahwa itu tidak bisa benar-benar FizzBuzz sehingga hanya Buzzes yang marah. Ketika itu bukan Fizzing atau Buzzing, itu chip di bot lain selama 30 putaran dan menyerah dan memilih bot lain untuk menargetkan jika tidak membuat kemajuan.

Tampil luar biasa tidak konsisten. Tidak apa-apa, memperbarui controller, sekarang sepertinya selalu ada di tengah-tengah paket.

— Transformasi Fourier Rin
sumber
Saya suka konsep ini. Terlepas dari situasi saat ini, ia terus berjalan dengan kecepatannya sendiri.
— Ness
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);
}

Cobalah online!

Mungkin tidak menang tetapi pasti akan mencoba yang terbaik untuk memastikan targetnya juga tidak. bullyBot juga bertani pada giliran pertama sehingga jika tidak ada pengaruh luar, ia akan mengalahkan targetnya 5-0 atau mengikatnya 5-5.

— Veskah
sumber
5

JustFarm

Saya pikir saya akan mulai sederhana.

function justFarm(me, others){
    return farm();
}
— Anonim
sumber
13
Bot ini akan bunuh diri karena biaya pertanian 2HP.
— Draco18s
@ Draco18s Meskipun putaran mungkin berakhir sebelum itu, tergantung pada jumlah bot
— Program Redwolf
1
Meskipun secara teknis benar, timer 50 putaran sangat singkat ketika waktu akhir default adalah 1000.
— Draco18s
Itu mengalahkan dua bot contoh, tetapi sekarang ada beberapa pengiriman lagi saya mungkin mencoba untuk menghasilkan sesuatu yang lebih baik.
— Anonim
@ Anonim Mungkin termasuk penyembuhan dan peningkatan pertanian sudah cukup. Karena mendapatkan emas terbanyak adalah tujuan akhir, menjaga agar pekerjaan utama bot bisa berhasil. Sejauh ini belum ada bot yang memiliki "mode" seperti mode heal dan mode farm, mungkin pendekatan yang menarik
— Redwolf Program
4

ScavengerBot (V2)

Menyadari itu bukan pemulung sebelumnya. Strategi baru adalah menunggu sampai dapat membunuh bot lain. Jika tidak ada yang bisa terbunuh, ia duduk dan membangun perisai.

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
sumber
1
me.levels.attacl?
— Draco18s
Tangkapan bagus, diperbaiki
— reffu
4

Murung

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

Strategi default Moody adalah meningkatkan pertanian dan penyembuhan untuk sementara waktu, lalu mengeluarkan bot lain dalam urutan nilai yang menurun. Namun, jika diserang, ia akan menjadi takut dan fokus kembali pada penyembuhan sebentar. Jika serangan dan "gagal", karena korban lebih menyembuhkan atau melindungi daripada serangan, korban akan marah dan pergi untuk meningkatkan kemampuan menyerang.

— histokrat
sumber
4

Bandit

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

Upaya pertama pada bot pembelajaran penguatan. Murni untuk saat ini mempersempit ruang pencarian. Semacam spinoff yang lebih cerdas dari FizzBuzz - ini mengulangi serangkaian tindakan khusus sebanyak lima kali; Kelima tindakan inilah yang dipilih oleh RL.

Tapi sebagian besar didasarkan pada penghitungan untuk saat ini - saya baru saja menghasilkan semua 3 ^ 5 = 243 permutasi dari serangkaian lima tindakan defensif yang berulang sendiri, dan menyimpan skor rata-rata mereka (dibagi 200, untuk mendapatkan keuntungan rata-rata lebih dari lima putaran) lebih dari 100 iterasi dalam storage.priorarray. Kemudian, selama pertandingan, itu menerapkan pendekatan epsilon-serakah untuk memperbarui daftar skor tersebut sehingga lebih bukti di masa depan. (Juga karena menggunakan epsilon = 0,3 memang jauh lebih baik daripada epsilon = 0,1 jadi saya hanya menyimpannya.)

Tidak apa-apa, secara konsisten menempatkan antara scavengerBot dan Optimist. Saat ini saya sedang melakukan beberapa pelatihan lebih lanjut tentang permainan nyata, dan mencari cara yang lebih baik untuk membingkai strategi, untuk melihat apakah saya dapat memperbaikinya.

— Transformasi Fourier Rin
sumber
4

Oportunis

Yang ini meminjam sedikit dari beberapa orang lain (terutama ScavengerBot (V2) dan Unkillable) karena mereka memiliki ide yang sama yang ada dalam pikiran saya, tetapi saya umumnya menyukai gaya yang serba bisa dan jack-of-all-trade lebih dari hanya berfokus pada satu-satunya. satu atau dua hal. Ini mungkin berarti bahwa saya tidak akan menang, tetapi itu harus di tengah-tengah di suatu tempat (yang terjadi pada saya sebagian besar waktu dalam banyak hal).

Jadi itu mencuri pembunuhan berair; menyembuhkan jika perlu; meningkatkan pertanian, menyerang, dan menyembuhkan dalam urutan itu; dan peternakan sebaliknya.

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();
    }
}
— Ness
sumber
1
Argumen 2 seharusnyaothers
— SuperStormer
4

ScaredBot

  1. Ia menemukan bot lain:
    • dengan serangan tertinggi
    • dengan sebagian besar kekayaan dan HP lebih rendah dari serangannya sendiri
  2. Jika perisai HP + lebih rendah dari yang ditemukan highest attack * (25% of bots), atau mendekati ujung bawah HP + shield, maka perisai
  3. Jika ia menemukan bot dengan perisai lebih rendah dari serangannya sendiri, ia akan menyerang bot itu.
  4. Jika kesehatannya baik < 50, itu akan sembuh.
  5. Jika ia bisa memutakhirkan tameng, sembuhkan, dan bertani, itu akan memperbarui perisai dengan level terendah
  6. Itu peternakan
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();
    }
}

Idenya adalah untuk tetap hidup sedapat mungkin dan coba dapatkan emas dengan cara yang aman dan murah untuk dapat ditingkatkan.

Prioritas peningkatan mungkin harus disesuaikan, serta kondisi saat menentukan apakah akan melindungi.

— pengguna24343
sumber
3

SmartFarmer

Pertanian, meningkatkan pertanian, menyembuhkan jika kesehatannya rendah. Pertanian tampaknya dikuasai habis sampai bot yang benar-benar ofensif tiba. Sekarang bot saya terbunuh :-(

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();
}
— PEMBELI
sumber
1
Saya (secara manual) menguji pada dasarnya strategi yang sama untuk melihat apa nilai maksimum yang dapat diperoleh dan angka terbaik yang bisa saya dapatkan, adalah dengan sedikit menunda ketika menyembuhkan ditingkatkan (saya menggunakan emas> = biaya * 2) dan naik ke lvl10 menyembuhkan .
— Nicolai
Pengganda harga itu adalah ide bagus. Saya menambahkan sesuatu yang serupa. Saya akan tertarik untuk melihat nomor apa yang Anda dapatkan
— B0RDERS
3

Mort

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

Setiap belokan, membandingkan keuntungan diamortisasi dari membunuh setiap bot dengan pertanian dan penyembuhan dan memilih opsi terbaik. Benar-benar harus menggunakan keadaan untuk mencari tahu berapa lama waktu yang dibutuhkan untuk membunuh bot, tetapi untuk saat ini hanya mengasumsikan setiap bot menyembuhkan atau melindungi rata-rata 5 poin per putaran dari kerusakan bot lainnya.

— histokrat
sumber
3

Bot ramah

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].hpadalah hp + shieldbukan hp...

— tsh
sumber
4
Adakah yang bisa membantu saya menerjemahkan nama fungsi ke Bahasa Inggris? ^ _ ^
— tsh
4
Menurut Google Translate, "闷声 发大财" berarti "Disadap". Cukup yakin bukan itu yang Anda inginkan dan sebenarnya adalah satu lagi epik Google Translate yang gagal ... Saya mencari lebih jauh dan semua hasil tampaknya menyebutkan bahwa tidak ada satu pun kata dalam bahasa Inggris yang dapat digunakan di sini, jadi mungkin lebih baik menyimpannya sebagai sebenarnya, karena tampaknya merupakan preposisi Cina yang umumnya berarti bahwa seseorang harus bekerja secara diam-diam dan membiarkan hasilnya berbicara sendiri dan mencapai filosofi tradisional. Sayangnya, saya tidak tahu bahasa Mandarin sama sekali untuk menerjemahkannya secara langsung. : D
— Erik the Outgolfer
1
sebagai penutur asli bahasa Cina, itu berarti sesuatu seperti "menghasilkan uang secara diam-diam": v 闷声 juga berkonotasi dengan sengaja diam, secara harfiah "menutupi suara"
— Transformasi Fourier oleh Rin
1
Sneaky? Di bawah radar? DontMindMe? AttentionDeflector?
— Peter Taylor
3

Akuntan

Bot praktis ini menghitung langkah yang paling menguntungkan secara ekonomi, tetapi ia suka menjaga profil serangannya tetap rendah untuk menghindari masalah dari semua bot main hakim sendiri. Dia tidak mencoba untuk memilih membantu yang tidak berdaya atau memangsa mereka. Sebaliknya, dia melakukan apa yang paling membantunya.

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();
}
— PEMBELI
sumber
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();
}

Ini masalahnya. Sudah sangat berbahaya di luar sana. Bertani sama sekali meningkatkan nilai Anda, membuat Anda menjadi target. Jadi benar-benar tidak aman untuk bertani sampai Anda telah membangun perisai besar dan semua kekerasan telah mereda. Kemudian Anda bisa mencungkil kepala Anda dari cangkang dan mulai bertani. Atau membunuh-membantu. Apa pun yang membayar lebih baik.

— histokrat
sumber
2

Wali

Saya dapat memiliki lebih dari satu pengiriman, bukan?

Garpu dari CampBot. Tidak melindungi, melainkan berfokus pada serangan. Menunjukkan preferensi untuk menyerang pemain dengan statistik serangan yang lebih tinggi, daripada menyerang secara acak seperti CampBot. Berfokus pada peningkatan pertaniannya daripada penyembuhan.

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()
    }
}
— Anonim
sumber
bot saya tidak menyerang secara acak ...
— SuperStormer
Anda dapat memposting sebanyak yang Anda inginkan, semakin meriah saya kira
— Program Redwolf
@SuperStormer Saya menyadari bahwa Anda tidak sepenuhnya acak, tetapi:let victim=potentialVictims[Math.floor(Math.random()*potentialVictims.length)]
— Anonim
tetapi pertama-tama menyaring yang tidak layak
— diserang
Saya sedang mengerjakan bot serupa bernama equalizer ketika Anda memposting ini. Saya masih menyesuaikannya, tapi saya suka beberapa ide Anda.
— B0RDERS
2

Rando

Pria konyol ini akan memilih tindakan berdasarkan keacakan seragam dengan beberapa bias. Jika tindakan yang dipilih secara acak tidak akan berhasil, maka tindakan itu turun ke pilihan berikutnya.

Jadi rata-rata, ia harus menyerang hampir 2/9 waktu dan pertanian hampir 3/9 waktu. Sisanya sekitar 1/9 kesempatan jika ia dapat meningkatkan, atau jika penyembuhan / perisai sepadan, dll.

Dia kemungkinan tidak akan tampil baik, tetapi setidaknya ada kemungkinan kecil bahwa dia berkuasa. Dan itulah seluruh tujuan Rando. Dia hanya perlu percaya pada dirinya sendiri! Semua opsi diletakkan di depannya. Dia hanya perlu memilih apa yang dibutuhkan untuk situasi apa pun.

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

(Saya tahu "default" tidak perlu, tapi saya pikir ini adalah praktik pengkodean yang baik untuk kode yang kuat.)

— Ness
sumber
2
"Dia hanya perlu percaya pada dirinya sendiri" ... Aku banyak tertawa sekarang
— Program Redwolf
2

Bunuh Bot

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

Bot sederhana, Kill Bot hanya ingin membunuh musuhnya. Karena perisai jauh lebih efisien daripada penyembuhan (terutama ketika diratakan), Kill Bot hanya berusaha untuk selalu menjadi target yang tidak menarik dengan melindungi dirinya sendiri setiap kali diserang. Kill Bot cukup baik di antara bot lemah, pasifis di sekitar sini (Anda bisa merasakan cemoohan bagi mereka).

— Spitemaster
sumber
3
Perhatikan bahwa o.attackini adalah level serangan, bukan kerusakannya
— Redwolf Programs
2

FarmHeal Bot

Dihasilkan dari bot @Anonymous 'JustFarm

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

Tidak bisa dihancurkan

Modifikasi bot Draco18, menggunakan perisai (lebih efektif terhadap bot lain)

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();
        }
    }
}
— Program Redwolf
sumber
Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.