Altın Savaş KoTH

43

Bu zorluk sona erdi. Yarışmacıların final puanlarını görmek için buraya tıklayın.

Bu mücadelede, her gönderim bir bottur. Her bot bir Javascript işlevi olmalıdır. Altın en yüksek toplamı elde etmek için botlar savaşacak. Altın yetiştirilebilir veya başka botların öldürülmesinden kazanılabilir ve şifa, saldırı, koruma ve çiftçiliği geliştirmek için kullanılır.

Amaç:

1000 dönüşe kadar birkaç tur (sadece bir bot bırakıldığında biter), toplam değeri en yüksek olan bot (elde edilen tüm altınların toplamı) kazanır.

Dönüşler:

Her sırayla, hayatta olan her bot (> 0 HP) bir defa çalıştırılır. Aşağıdakilerden biri olabilecek bir hamle döndürür:

  • İyileştirme: HP'yi Kazandı
  • Saldırı: HP'yi başka bir bottan kaldırır
  • Kalkan: Daha sonraki saldırılara karşı savunur
  • Stun: Başka bir botun sıradaki sırasını atlar
  • Çiftlik: HP pahasına altın kazanır
  • Yükseltme: Bazı hareketleri daha iyi hale getirin

Tüm botlar harekete geçmeden hareketlerini geri getireceklerdir, bu yüzden sersemletmek, iyileşmek, saldırmak, kalkan vb. Bu sırada hareket eden botları etkilemeyecektir. Örneğin, Bot A, Bot B'yi sersemletirse ve Bot B, A dönüşünden sonra sırayla, Bot B yine aynı sırayla hareket eder ve sersemletici bir sonraki dönüşde gerçekleşir.

Savaş, Çiftçilik ve Yükseltme:

Her botta maksimum 100 HP ve 0 ile 99 arasında atanmış bir UID bulunur. Bu UID her turdan sonra değişir ve botlar birbirlerini nasıl takip eder.

İyileştirme, seviyesine göre belirlenen bir HP miktarı ekleyerek en basit hamlelerden biridir (5 HP'de başlar). Bir bot 100 HP'yi geçemez.

Botuna UID'sine saldırmak, olası bir hamledir ve 0 HP'de 5 HP'lik bir hasar verir. Botlar ayrıca UID'leri kullanan sonraki sıralarını atlayarak da sersemletilebilir.

Robotlar, sınırsız olan ilave HP korumasına sahiptir. Bu koruyucu HP, diğer botların doğrudan saldırılarından aldığı hasarı emer ve ekranlama yoluyla eklenir. 0 düzeyinde, ekranlama 5 kalkan HP ekler.

Çiftçilik, 0 HP seviyesinde 2 HP karşılığında 5 altın kazanacak. Bu 2 HP korumalı olamaz. Altın için tek kullanım (kazanmanın ötesinde) hamleleri yükseltmektir. İyileştirme, saldırma ve koruma 5 HP taban değerine sahiptir ve çiftçilik 5 altından başlar. Bu hamlelerin her biri, 0 ile başlayan bireysel seviyelere sahiptir. Bu formüller, L'nin seviye olduğu bir hamlenin HP veya altındaki değerini belirleyecektir:

  • şifa: L + 5
  • saldırmak: 1.25L + 5
  • koruyucu: 1.5L + 5
  • çiftçilik: 2L + 5

Herhangi bir hamlenin yükseltilmesinin maliyeti belirli bir seviye için aynıdır ve 2.5L² + 2.5L + 10L'nin geçerli seviye olduğu yerde belirlenir . Bir bot bu fonksiyonu cost(currentLevel)belirlemek için kısayol olarak kullanabilir .

Botlar 25 altınla başlar ve bu sayede ya iki hamle seviye 1’e, biri de seviye 2’ye hızlı bir şekilde yükseltilir. Bir botu öldürmek, toplam değerinin yarısı kadar altın verir, yuvarlanır ve iki bot aynı sırayla başka birini öldürürse, ikisi de ödülü alır.

Giriş çıkış:

Kontrol cihazı ile iletişim kurmak için, fonksiyonun dönüş değeri taşıma bilgisi göndermek için kullanılır. Bunlardan biri iade edilmelidir:

  • İyileşmek: heal()
  • saldır: attack(uid)
  • kalkan: shield()
  • stun: stun(uid)
  • Çiftlik: farm()
  • Yükselt: upgrade("heal" / "attack" / "shield" / "farm")

Bir dönüşü atlamak (hiçbir şey yapmamak), hiçbir şey döndürmek veya sahte bir değer döndürmek için.

Mevcut dönüş numarasını almak için (1'den başlar), kullanın turn().

İşlevinizin argümanları botunuz hakkında bilgi, diğer botların kullanıcı kimlikleri ve kayıt arası depolama içerecektir. İlk bağımsız değişken aşağıdaki özelliklere sahip bir amacıdır: uid, hp, goldve shield. Bunlar botunuzun şu anki bilgilerinin kopyaları. Bir yuvalanmış nesne de vardır levelsseviyesi numaraları ile, heal, attack, shield, ve farm.

İkinci bağımsız değişken bir özelliklerini içeren bir nesne olarak biçimlendirilmiş seninkinden dışındaki tüm canlı botlar karıştırılmış bir dizi olduğu uid, hp(artı kalkan), worthve attack(saldırı düzeyi). Üçüncü argüman, dönüş arası depolama için kullanılabilecek boş bir nesnedir.

Örnek Botlar:

Bu bot saldırı seviyesini 5. seviyeye yükseltene kadar artacak, sonra ölene (veya kazanana kadar) her dönüşe rastgele bir bot atacak. İyileşme / koruma eksikliği nedeniyle çok etkili değil.

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

Bu botun iki modu var: saldırgan ve savunmacı. Rastgele bir bot sersemletir veya savunma modundayken iyileşir ve saldırgan moddayken de saldırıya ya da kalkan olur. Mümkün olduğunca saldırılarını yükseltmeye çalışacaktır.

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

Kurallar:

  • Standart Loopholes yasak
  • Botlar kapsamları dışında herhangi bir değişken okuyamaz, değiştiremez veya ekleyemez, hile yapmaya çalışamaz ve denetleyici tarafından tanımlanmış veya DOM işlevlerini çağırmayabilir
  • Dönüş değeri sahte olmalı veya yukarıdaki işlev çıktılarından biri olmalı
  • Botlar belirli bir botu hedef alacak şekilde tasarlanmamalı, ortak stratejilerden yararlanmak için tasarlanmalıdır.
  • Botlar kendilerine saldıramayabilir (@Ness tarafından yapılan bir yorum nedeniyle keşfedildi)
  • Botlar, makul bir şekilde ayrı girdiler olarak kabul edilebilecek diğer botlardan yeterince farklı olmalıdır.
  • Takımlaşmaya artık izin verilmiyor
  • Kontrolör burada bulunabilir
  • Sohbet odası

Yeni Denetleyici Hata Ayıklama:

Dosyayı kullanarak, bir botun özelliğinin gold-battle-log.jsdeğerini 0 (günlük kaydı yok), 1 (günlük hareketi) veya 2 (günlük hareketi, hp, altın, düzey vb.) Olarak ayarlayabilirsiniz.debugbotData

Meydan okuma 9 Ağustos Cuma günü saat 17.00 UTC'de sona eriyor

king-of-the-hill  javascript 
— Redwolf Programları
kaynak
4
Tüm botlarla bir öz oluşturdu. gist.github.com/Draco18s/2efbf95edcf98d6b1f264e26bbb669d1 Güncel tutmak için gayret göstereceğim (ancak düzgün bir başlangıç ​​değilse).
— Draco18,
4
— Redwolf Programları 07
4
Bu soruyu kapatmak için oy kullanıyorum çünkü zaten yeni cevaplara fiili olarak kapatıldı ("Bu zorluk sona erdi. Son puanları görmek için ...")
— pppery
3
@pppery Yapamaz mısın? Rekabetçi olmayan cevaplar konusunda iyi olurum [closed]ve sonuçta sıradan izleyicilerin düşük kalitedeki veya konuyla ilgisiz olduklarını varsaydıkları için zorlukları okumayı atlamaları muhtemel.
— Redwolf Programları
5
@ pppery Bugüne kadar bitmiş olduğu için kapatıldığını hiç bir zaman duymadım ve uygulamak istediğin sosyal kısıtlamanın bile olmadığını savunuyorum. Kapatmaya gerek yok ve kapalı olmasını istemiyorum. Bana göre, sitenin iyiliği yerine kapanış uğruna kapanış gibi görünüyor. Birisi eski bir soruya cevap göndermek istiyorsa, yapabilmelidir. Ciddi yarışmacı kuralından sonra, ilan edildiğinde ciddi bir yarışmacı olması gerektiğini söyleyen hiçbir not yoktur; Bir cevap hala kazanmak için bir rakip olmasa bile, mücadele için ciddi bir rakip olabilir
— Redwolf Programları 04

Yanıtlar:

16

Öldürülemez

Undyable den çatal .

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

Üstel yükseltmelerin maliyeti göz önüne alındığında, iyileşmeyi yükseltemezsek, botun daha verimli bir şekilde altın toplamasına izin verirsek, çiftçiliği yükseltebiliriz.

— Draco18s
kaynak
Testlerimdeki rekabeti kesinlikle ezmek
— Redwolf Programları
1
Bu botun biraz daha güçlü olabileceğini düşünüyorum, ilk ifkullanılan <=ifadeydi - şu anda asla tam olarak iyileşmeyecek.
— Scoots
@Scoots Ne kadar önemli olacağından emin değilim, ama bunu değiştireceğim.
— Draco18,
2
@ Draco18s Çok az önemli olduğuna eminim - ama bu site tamamen küçük, pratik olarak önemsiz gelişmeler hakkında değil mi? :)
— Scoots
@Scoots Maksimum sağlığa şifa vermek bu zorlukta pek önemli değil çünkü gerçek bir saldırı tehdidi yok. Gerçekten saldırgan tek bot bullybot ve onun hakkında hiçbir şey yapamazsın. Aslında tam sağlıkta kalmak performansı düşürebilir.
— 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();
            }
        }
    }
}

Çok fazla bot var, dolaşacak kadar altın yok. Bu bot bir çözüm öneriyor.

Soykırım, evet, ama rastgele, tarafsız, adil ve zengin ve fakir.

Ona deli dediler.

ThanosBot bot topluluğu için en iyisini istiyor ve tüm yolu takip etmeye istekli. Başlangıçta, kaynaklarını daha verimli bir şekilde toplamak ve savaş kazanmak için saldırısını, çiftçiliğini ve iyileşmesini geliştirecek. Prograssively, yaklaşmakta olan savaşlar için hala kaynak toplarken insanlara rastgele saldırmaya başlayacak. Ordusunu, silahlarını ve kendisini geliştirmeye devam edecek.

Nüfusun% 50'si ortadan kalktıktan sonra, doğmuş botlar yalnızca tam karınlarını tanıyacak ve açık gökyüzü görecek, bir çiftçilik hayatına çekilecek ve güneşin minnettar bir evrende yükselişini izleyecektir. Tamamen pasifist olacak, sadece sebze çorbaları ve çiftçilikle kendini iyileştirecek.

— Kaito Kid
kaynak
6
"
— Attack
11

Hırsızı öldür

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

Şimdi sadece öldürmek değil, öldürmek de çalmak değil!

Bu bot çiftlik dışında pek bir şey yapmıyor ve olasılığı fark ettiğinde ölmekte olan bir düşmana son darbeyi yapıyor ve bir şekilde çok iyi olmayı başarabiliyor.

— dzaima
kaynak
İşe yarıyor, çünkü öldürme darbesinde yer alan tüm botlar tam ödül alıyor.
— Draco18,
@ Draco18s Neden iyi olabileceğini anlıyorum, bu kadar basit bir fikrin bir sonraki en iyi botun puanının ortalama 2 katı kadar olmasını beklemiyordum (bunu yaparken).
— dzaima
Hehe, bu adil. Tüm botları indirmem gerekecek ve başka bir çözüm bulabilecek miyim diye bakmalıyım.
— Draco18,
9

Ses düzenleyici

Bu bot bot topluluğundaki barışı yeniden sağlamayı amaçlıyor. Acımasızca en yüksek saldırıya sahip botları hedef alıyor, ancak botun iyileşmesi kendi saldırısından daha iyiyse pes ediyor. Saldırılarından daha kötü iyileşen hiçbir bot kalmazsa, barışçıl bir çiftçilik hayatına çekilecek.

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
kaynak
8

optimist

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

Zamanının% 80'ini barış içinde çiftçilikle geçirebileceğini varsayar, bu nedenle çiftçiliği maksimize ederek başlar ve ancak daha sonra mücadele becerilerine dikkat etmeye başlar. Elbette hiçbir şey yanlış gitmeyecek!

— histocrat
kaynak
8

Asist öldür

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

Nişan alma hasarı ve hala tam kredi alabiliyorsanız neden saldırı değerini yükseltin?

Kill Stealer'ı geri almak için bir kez daha. İfadelerin her zaman doğru olduğu birkaç kod bloğunu basitleştirebildim ve orijinalin üzerinde büyük kazanımlara neden olan bazı numaralarla uğraştım.

Öldürmeden önce dönüşe yardımcı olması muhtemel olan varlıklı bir rakibinin çarpıcı şekilde zekice olduğunu anlamak için @dzaima'ya vermeliyim. (Çok) birkaç zamandan Stun()birinin olumlu bir toplam sonucu vardır. Bir kez daha Kill Stealer'ın benzer bir mantık yayınlayacağını bildiğim için Kill Assist "ikinci bir en iyi" hedef arar (bazı takdirlerde) ve bunun yerine onları şaşırtıyor.

Ölmek üzere olan botun etkilenmesini önlemek ve öldürmek için en büyük olasılıkla öldürülmesini önlemek için küçük güncelleme.

Örnek sonuçlar (1000 maçtan sonra ilk 5'i kesildi)

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
kaynak
Bekle, hangi dünyada Kaptan Çiftçi 14 ayar altın alıyor?
— Redwolf Programları
Bu bir:runGame(1) results: [...] captFarmer: 13768
— Draco18
Bu oldukça beklenmedik bir şekilde yüksek ... testlerimde genelde 10
— bin dolar alıyor
* shrugh * Fikrim yok. Her şeyin temiz olmasını sağlamak için otomatik bir güncelleme yapacağım.
— Draco18,
En son botun sonunda en sevdiğim bot.
— Gece2
7

Yenilmez Bot (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
kaynak
Bana aldırma ... Bunu ödünç alacağım.
— Draco18,
6

PatientStrategistBot

Gerektiği gibi çerçevelemeye ve savunmaya başlayan bir bot yazmaya çalıştım ve daha sonra oyundaki diğer yüksek değerli botları öldürmeye geçtim.

Şu anda bu, oyunun başlangıcında bir cinayet çetesi tarafından öldürüldüğü ya da hücum modunda bir yere sıkıştığı için düzgün çalışmıyor gibi görünüyor.

Bu benim ilk JS kodum olduğu için hala çok mutlu, bu yüzden ... (buradan kod parçacıklarını çaldım ve bu, tüm JS temel sözdiziminin googlinginden daha hızlı olmasına neden oldu)

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

İsviçre

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

Adından da anlaşılacağı gibi, bu bot nötr yavaşça altın kadar bina çoğunlukla nötr (şimdi o yardımcı olur öldürmek ölecek botlar) ve sadece çiftlikler ve iyileşir, ( sadece İsviçre'de gibi )

— SuperStormer
kaynak
6

Çiftlikler, Saldırılar, Kalkanlar ve Hatta İyileşen Bot Asla Sersemleten

(Kısa adı TBTFASAEHBNS , TBTPTGCBCBA ile karıştırılmaması gerekir )

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

Bu bot temelde:

  • Tarımda başlangıçta gelişir
  • Gerektiğinde kendini savunur
  • Ne zaman öldürebileceğini veya ne zaman birini öldüreceğini düşünen saldırılar
  • Burada ve daha sonra yükseltir
  • Zamanın geri kalanında çiftlikler
  • Asla sersemletme

Düzenleme 1: Bir sorun düzeltildi ve botla yapılan pek çok oyunla yapılan testlere dayanarak bazı küçük şeyler geliştirildi.

Düzenleme 2: Azaltılmış kalkan yükseltmeleri.

— night2
kaynak
2
İsmi görür görmez senin botun olacağını biliyordum (:
— Redwolf Programları
Uzun isimler için üzgünüm, ama bağımlısıyım!
— Gece2
1
Belki de iyi bir botun işareti ... testlerim 5. sırada olduğunu gösteriyor
— Redwolf Programları
5

SniperBot

Bu bot, ancak birisi düzenli olarak saldıran botlar eklemeye başlarsa etkili olacaktır. SmartFarmer benim güncel optimize çözümüm

  1. tek atışta iyileşirse iyileşir
  2. 30 yaşın altında olursa iyileşir
  3. Saldırı bot bot seçip tarımdan daha fazla para kazanabiliyorsa
  4. eğer karşılayabiliyorsa, tarımı yükseltiyor
  5. 80 sağlık altında ve iyileşebilir eğer iyileştirme şifa
  6. çiftlikleri

akbabaların bir saldırıya ihtiyacı yok

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
kaynak
int2. satırda beklenmeyen tanımlayıcı ( ). ReferenceError: health tanımlanmadı.
— Draco18,
Olmalı mı me.hp?
— mbomb007
üzgünüm. javascript için yeni. yardımın için teşekkürler
— B0RDERS
Sizin if(me.hp <30 && ...)o (65 lvl) önemi iyileşmek saçma bir seviyede ihtiyacı nedeniyle sadece birinci fıkrası basitleştirilmiş olabilir
— Veskah
@Veskah Buna dikkat çektiğiniz için teşekkürler. Min hp daha yüksek olduğu zamandan kalan bir şeydi
— 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);
}

BullyBot ve diğer bazı bitlerin ezilmesi. İyimser, düşündüğüm kısa ve tatlı bir fırsatçı saldırı önsezisine sahipti (diğer botlar da benzer hesaplamalar yapıyor).

Hedefi çarpıcı bir şekilde vurmak yerine, onları tatlı, tatlı ganimetleriyle öldürür . Ayrıca, zorbalık için sürüdeki en zayıf olanı hedeflemektedir, ancak en zayıf hedefin HP'si çok yüksekse pes edecek ve tarıma devam edecektir.

— Draco18s
kaynak
Kendini ölümüne yetiştiriyorsun. Düzenlememi kabul et :)
— B0RDERS
1
@AndrewBorders Ha, bunu bile düşünmedi. Teşekkürler.
— Draco18
Bu bot, koruyucu botlar gelene kadar harikaydı.
— B0RDERS
@ B0RDERS Kalkan zaman kaybetse bile çok güçlüdür.
— Draco18,
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);
}

Çoğunlukla saldırgan bot. Son derece gerçekten FizzBuzz yapamadığı için üzülüyor, bu yüzden sadece öfkeyle Buzzes. Fizzing veya Buzzing olmadığında, 30 tur boyunca başka bir botta fişleri kopar ve vazgeçip ilerlemiyorsa hedeflemesi için başka bir bot seçer.

Olağanüstü tutarsızca performans sergiliyor. Boşver, kontrolör güncellendi, şimdi her zaman paketin ortasında görünüyor.

— Rin Fourier dönüşümü
kaynak
Bu konsepti sevdim. Mevcut durumdan bağımsız olarak, kendi hızına bağlı kalmaya devam ediyor.
— 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);
}

Çevrimiçi deneyin!

Kazanmayabilir ama kesinlikle hedefinin de yapmadığından emin olmak için elinden geleni yapacak. bullyBot ayrıca ilk dönüşte çiftlikleri kurar, böylelikle dışarıdan bir etkisi olmazsa hedefini 5-0 yener veya 5-5'e bağlar.

— Veskah
kaynak
5

JustFarm

Basit başlayacağımı düşündüm.

function justFarm(me, others){
    return farm();
}
— Anonim
kaynak
13
Bu bot 2HP tarım maliyeti nedeniyle intihar edecek.
— Draco18,
@ Draco18s Her ne kadar tur daha önce bitebilir olsa da, bot sayısına bağlı olarak
— Redwolf Programları
1
Teknik olarak doğru olsa da , 50
— bit
İki örnek botu yendi, ama şimdi daha iyi bir şey bulmaya çalışabileceğim birkaç başvuru daha var.
— Anonim
@ Anonim Belki şifa ve çiftçilik yükseltmeleri de dahil olmak üzere yeterli olacaktır. En fazla altın almak en büyük amaç olduğu için, botun ana işi olarak çalışabilir. Şimdiye dek
— sağlık
4

ScavengerBot (V2)

Daha önce bir çöpçü olmadığını fark ettim. Yeni strateji, başka bir botu öldürene kadar beklemek. Hiç kimse öldürülemezse, oturur ve kalkan oluşturur.

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
kaynak
1
me.levels.attacl?
— Draco18,
İyi yakalama, sabit
— reffu
4

huysuz

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

Moody's'in varsayılan stratejisi, tarımı ve iyileşmeyi bir süre daha yükseltmek, ardından diğer botları azalan değerde çıkarmaktır. Ancak, saldırıya uğrarsa korkar ve biraz iyileşmeye odaklanır. Eğer saldırır ve "başarısız olur", çünkü mağdur saldırıdan daha etkili bir şekilde iyileşiyor veya korunuyordu, sinirlenecek ve hücum yeteneklerini geliştirmek için harekete geçecektir.

— histocrat
kaynak
4

eşkıya

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

Bir takviye öğrenme botundaki ilk girişim. Arama alanını daraltmak için şimdilik tamamen savunma. Daha akıllı bir FizzBuzz dizisi - bu, belirli bir beş işlem serisini tekrar tekrar tekrarlar; Beş eylem, RL tarafından seçilenlerdir.

Ama şu an için çoğunlukla numaralandırmaya dayanıyor - Ben sadece tekrar tekrar tekrarlayan beş defansif eylem serisinin tüm 3 ^ 5 = 243 permütasyonunu oluşturdum ve ortalama puanlarını elde etmek için ortalama puanlarını (200'e bölündü) sakladım. beş dönüş) storage.priordizideki 100'den fazla yineleme . Daha sonra, oyun sırasında, bu skor listelerini güncellemek için epsilon açgözlü bir yaklaşım uygular, böylece daha geleceğe yöneliktir. (Ayrıca, epsilon = 0.3 kullanmak, epsilon = 0.1'den daha iyi sonuç verdiğinden, sadece sakladım.)

Tamamen, tutarlı bir şekilde scavengerBot ve Optimist arasında yerleştirmek. Şu anda gerçek oyunlar hakkında daha fazla eğitim yapıyorum ve stratejiyi geliştirmenin daha iyi yollarını görmek için daha iyi yollar aramaya çalışıyorum.

— Rin Fourier dönüşümü
kaynak
4

Fırsatçı

Bu, aklımdaki düşüncelere sahip oldukları için bir kaç diğerinden (özellikle ScavengerBot (V2) ve Unkillable) biraz ödünç alıyor, ancak genel olarak iyi odaklanma ve her şeyi tamamlayan stilleri yalnızca odaklanmayı daha çok seviyorum bir veya iki şey. Bu muhtemelen kazanamayacağım anlamına gelecektir, ancak ortada bir yerde olmalı (bu çoğu zaman başıma gelir).

Böylece sulu öldürür çaldı; gerekirse iyileşir; çiftlik, saldırı ve iyileştirme sırasını yükseltir; ve aksi takdirde çiftlikler.

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
kaynak
1
2. argüman olmalıothers
— SuperStormer
4

ScaredBot

  1. Başka botlar bulur:
    • en yüksek saldırı ile
    • çoğu servet ve HP kendi saldırısından daha düşük
  2. HP + kalkanı bulunandan daha düşükse highest attack * (25% of bots)veya alt tarafına HP + shieldyaklaşırsa, kalkanlar
  3. Kendi saldırısından daha düşük kalkanlı bir bot bulmuşsa, ona saldırır.
  4. Sağlığı ise < 50iyileşir.
  5. Kalkan, iyileştirme ve tarladan herhangi birini yükseltebiliyorsa, en düşük seviyeye sahip olanı yükseltir.
  6. Çiftlikleri
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();
    }
}

Buradaki fikir mümkün olan en uzun süre hayatta kalmak ve aksi takdirde yükseltme yapabilmek için güvenli ve ucuz bir şekilde altın elde etmeyi denemek.

Yükseltme öncelikleri muhtemelen korumanın gerekip gerekmediğine karar verirken olduğu gibi ince ayar yapılmalıdır.

— user24343
kaynak
3

SmartFarmer

Çiftlikler, çiftçilik yükseltmeleri, sağlık durumunun azalması durumunda iyileşir. Gerçekten saldırgan robotlar gelinceye kadar çiftçilik çok güçlendi. Şimdi botum öldürülüyor :-(

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
kaynak
1
Elde edilen maksimum değerin ne olduğunu ve elde edebileceğim en iyi rakamları görmek için temelde aynı stratejiyi (elle) test ediyordum, iyileştirme yapıldığında biraz gecikmekteydim (altın kullandım> = maliyet * 2) ve lvl10 iyileşmesine kadar gidiyordum. .
— Nicolai,
Bu fiyat çarpanı iyi bir fikir. Benzer bir şey ekledim. Hangi numaralara sahip olduğunuzu görmek isterdim
— B0RDERS
3

av borusu

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

Her dönüş, her bir botu öldürmenin amortisman karını tarım ve şifa ile karşılaştırır ve en iyi seçeneği seçer. Gerçekten bir botu öldürmenin ne kadar süreceğini bulmak için durumu kullanmalıdır, ancak şu an için her botun diğer botların yaptığı zarardan net dönüş puanı ortalaması 5 puan artar.

— histocrat
kaynak
3

Dost bot

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].hpolduğu hp + shieldyerine hp...

— TSH
kaynak
4
Birisi işlev adını İngilizceye çevirmeme yardımcı olabilir mi? ^ _ ^
— tsh
4
Google Translate'e göre, "闷声 发大财" "Muffled" anlamına gelir. İstediğiniz şeyin bu olmadığından ve aslında bir başka Google Translate epikinin başarısız olduğundan eminim ... Daha fazla araştırdım ve tüm sonuçlar burada kullanılabilecek tek bir İngilizce kelime olmadığını söylüyor gibi görünüyor. Aslında, genellikle sessizce çalışılması ve sonuçların kendileri için konuşmasına ve geleneksel bir felsefeye ulaşmasına izin verilmesi gerektiği anlamına gelen bir Çinli edat gibi görünüyor. Maalesef, Çince’yi doğrudan çevirmeyi hiç tanımıyorum. : D
— Outgolfer Erik
1
Ana dili Çince olan bir konuşmacı olarak, "sessizce büyük bir servet kazan" gibi bir şey anlamına gelir: v 闷声 aynı zamanda kasıtlı olarak sessiz, kelimenin tam anlamıyla "sesi kapatarak" bağlanır
— Rin's Fourier dönüşümü
1
Sinsi? Radarın altında? DontMindMe? AttentionDeflector?
— Peter Taylor,
3

Muhasebeci

Bu pratik bot ekonomik olarak en faydalı olan hareketi hesaplar, ancak uyanık botların derdinden kaçınmak için saldırı profilini düşük tutmayı sever. Savunmasız yardım almaya ya da üzerlerinde av kurmaya çalışmıyor. Aksine, ona en çok yardımcı olan şeyi yapar.

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

İşte şey. Dışarısı çok tehlikeli bir hal aldı. Çiftçilik, değerinizi artırarak sizi bir hedef haline getirir. Bu yüzden, kocaman bir kalkan inşa edene ve tüm şiddet kesilinceye kadar çiftlik yapmak gerçekten güvenli değil. Daha sonra başınızı kabuğundan çıkarabilir ve çiftçiliğe başlayabilirsiniz. Veya öldürmeye yardım etme. Hangisi daha iyi öder.

— histocrat
kaynak
2

Muhafız

Birden fazla başvuru yapabilirim, değil mi?

Bir CampBot çatalı. Kalkan değil, saldırmaya odaklanmak. CampBot gibi rastgele vurmak yerine, daha yüksek saldırı istatistikleri olan oyunculara saldırma tercihini gösterir. İyileşme yerine çiftçiliğini geliştirmeye odaklanır.

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
kaynak
benim bot rastgele saldırı
— yapmaz
İstediğiniz kadar
— yayınlayabilirsiniz,
@SuperStormer Sizinki tamamen rastgele olmadığını biliyorum, ama:let victim=potentialVictims[Math.floor(Math.random()*potentialVictims.length)]
— Anonim
ama önce saldırmaya değmez olanları filtreliyor
— SuperStormer
Bunu gönderirken ekolayzer adında benzer bir bot üzerinde çalışıyordum. Hala ince ayar yapıyorum, ama bazı fikirlerini beğendim.
— B0RDERS
2

Rando

Bu aptal adam bazı önyargılarla tek tip rastlantısallığa dayalı eylemler seçecek. Rastgele seçilen bir eylem işe yaramazsa, bir sonraki seçime düşer.

Bu nedenle, ortalama olarak, zamanın neredeyse 2 / 9'una saldırmalı ve zamanın 3 / 9'unu çiftleştirmelidir. Gerisi, yükseltme yapabiliyorsa veya iyileşme / korumaya değerse, yaklaşık 1/9 şans.

Muhtemelen iyi performans göstermeyecek, ama en azından yüce hüküm sürdüğü için küçük bir şans var. Ve bu Rando'nun bütün amacı. Sadece kendine inanması gerekiyor! Tüm seçenekler önüne koyulur. Sadece belirli bir durum için neyin gerekli olduğunu seçmesi gerekiyor.

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

("Varsayılan" öğesinin gereksiz olduğunu biliyorum, ancak sağlam kod için iyi bir kodlama uygulaması olduğunu düşünüyorum.)

— Ness
kaynak
2
"Sadece kendine inanması gerekiyor" ... Şu an çok gülüyorum
— Redwolf Programları 20
2

Bot öldür

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

Basit bir bot, Kill Bot sadece düşmanlarını öldürmek istiyor. Koruma, iyileştirmekten çok daha etkili olduğundan (özellikle seviyelendiğinde), Kill Bot, her saldırıda kendisini koruyarak her zaman çekici olmayan bir hedef olmaya çalışır. Kill Bot, buradaki zayıf, pasifik botların arasında oldukça iyi iş çıkarır (kendileri için onun acısını hissedebilirsiniz).

— Spitemaster
kaynak
3
Not o.attacksaldırı seviyesi değil, onun hasar
— Redwolf Programları
2

FarmHeal Bot

@Anonymous 'JustFarm bot tarafından Çatal

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

yok edilemez

Draco18 botlarının modifiye edilmesi, kalkanların kullanılması (diğer botlara karşı daha etkili)

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();
        }
    }
}
— Redwolf Programları
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.