43

यह चुनौती समाप्त हो गई है। प्रतियोगियों के अंतिम स्कोर को देखने के लिए, यहां क्लिक करें

इस चुनौती में, प्रत्येक प्रस्तुत एक बॉट है। प्रत्येक बॉट एक जावास्क्रिप्ट फ़ंक्शन होना चाहिए। बॉट सोने में उच्चतम कुल मूल्य प्राप्त करने के लिए लड़ेंगे। सोने की खेती की जा सकती है, या अन्य बोट्स को मारने से कमाया जा सकता है और इसका उपयोग हीलिंग, आक्रमण, परिरक्षण और खेती को उन्नत करने के लिए किया जाता है।

उद्देश्य:

1000 से अधिक घुमाव वाले कई राउंड्स (केवल एक बॉट के समाप्त होने पर समाप्त होता है), सबसे अधिक कुल मूल्य (प्राप्त सभी सोने का योग) वाला बॉट विजेता है।

बदल जाता है:

प्रत्येक मोड़ में, प्रत्येक बॉट जो जीवित है (> 0 एचपी) एक बार चलाया जाएगा। यह एक चाल लौटा सकता है, जो निम्नलिखित में से एक हो सकता है:

हील: एचपी को नियंत्रित करता है
हमला: एचपी को दूसरे बॉट से निकालता है
शील्ड: बाद के हमलों के खिलाफ रक्षा करता है
अचेत करना: दूसरे बॉट की अगली बारी को छोड़ देता है
फार्म: एचपी की कीमत पर सोना कमाता है
अपग्रेड: कुछ चालों को बेहतर बनाएं

सभी बॉट किसी भी निष्पादित होने से पहले अपनी चाल वापस कर देंगे, इसलिए एक स्टन, चंगा, हमला, ढाल, आदि उस मोड़ में बाद में चलने वाले किसी भी बॉट को प्रभावित नहीं करेगा। उदाहरण के लिए, यदि बॉट ए, बॉट बी, और बॉट बी टर्न ऑर्डर में बॉट ए के बाद है, तो बॉट बी बाद में भी उसी मोड़ पर आगे बढ़ेगा और स्टन अगले मोड़ पर होगा।

मुकाबला, खेती और उन्नयन:

प्रत्येक बॉट में अधिकतम 100 एचपी होता है, और 0 और 99 के बीच एक यूआईडी निर्दिष्ट होता है। यह यूआईडी हर दौर के बाद बदलता है, और यह है कि बॉट एक दूसरे का ट्रैक कैसे रखते हैं।

हीलिंग सबसे सरल चालों में से एक है, अपने स्तर से निर्धारित एचपी की मात्रा को जोड़ना (5 एचपी से शुरू होता है)। एक बॉट पिछले 100 एचपी को ठीक नहीं कर सकता है।

यूआईडी द्वारा एक बॉट पर हमला करना एक और संभावित कदम है, जिसका स्तर 0. 5 स्तर पर एचपी की क्षति के साथ है। बॉट्स भी स्तब्ध रह सकते हैं, अपने अगले मोड़ को छोड़ देते हैं, जो यूआईडी का भी उपयोग करता है।

बॉट में अतिरिक्त ढाल एचपी है, जिसकी कोई सीमा नहीं है। यह ढाल एचपी अन्य बॉट से सीधे हमलों से नुकसान को अवशोषित करेगी, और परिरक्षण द्वारा जोड़ा जाता है। स्तर 0 पर, परिरक्षण 5 ढाल एचपी जोड़ता है।

खेती 2 एचपी की लागत से, 0 के स्तर पर 5 स्वर्ण अर्जित करेगी। इस 2 एचपी को परिरक्षित नहीं किया जा सकता है। सोने (जीतने से परे) के लिए एकमात्र उपयोग चाल को उन्नत करना है। हीलिंग, आक्रमण और परिरक्षण का आधार मूल्य 5 HP है, और खेती 5 स्वर्ण से शुरू होती है। उन चालों में से प्रत्येक में व्यक्तिगत स्तर होते हैं, जो 0. पर शुरू होते हैं। ये सूत्र एक कदम के एचपी या सोने में मूल्य का निर्धारण करेंगे, जहां एल स्तर है:

हीलिंग: L + 5
हमला: 1.25L + 5
परिरक्षण: 1.5L + 5
खेती: 2L + 5

किसी भी चाल को उन्नत करने की लागत एक निश्चित स्तर के लिए समान है, और यह निर्धारित किया जाता है 2.5L² + 2.5L + 10, जहां एल वर्तमान स्तर है। एक बॉट इसे cost(currentLevel)निर्धारित करने के लिए एक शॉर्टकट के रूप में फ़ंक्शन का उपयोग कर सकता है ।

बॉट्स 25 सोने से शुरू होते हैं, जिससे वे जल्दी से या तो दो चालों को स्तर 1 पर ले जा सकते हैं, या एक स्तर पर ले जा सकते हैं 2. यह शुरुआत सोना कुल मूल्य के बॉट की ओर नहीं गिना जाता है। एक बॉट को मारने से आपको सोने में उसकी कुल कीमत का आधा हिस्सा मिलता है, गोल किया जाता है, और अगर दो बॉट एक ही मोड़ में दूसरे को मारते हैं, तो वे दोनों को इनाम मिलता है।

इनपुट आउटपुट:

नियंत्रक के साथ संवाद करने के लिए, चाल जानकारी भेजने के लिए फ़ंक्शन के रिटर्न मान का उपयोग किया जाता है। इनमें से एक को लौटाया जाना चाहिए:

चंगा: heal()
हमला: attack(uid)
शील्ड: shield()
अचेत: stun(uid)
खेत: farm()
अपग्रेड: upgrade("heal" / "attack" / "shield" / "farm")

एक मोड़ (कुछ भी नहीं) को छोड़ने के लिए, कुछ भी नहीं लौटाएं, या एक झूठा मान लौटाएं।

वर्तमान टर्न नंबर प्राप्त करने के लिए (1 से शुरू होता है), उपयोग करें turn()।

आपके फ़ंक्शन के तर्कों में आपके बॉट, अन्य बॉट्स के यूआईडी और टर्न-स्टोरेज के बारे में जानकारी शामिल होगी। पहला तर्क निम्नलिखित गुणों के साथ एक वस्तु है: uid, hp, gold, और shield। ये आपके बॉट की वर्तमान जानकारी की प्रतियां हैं। वहाँ भी एक नेस्टेड वस्तु है levelsके स्तर की संख्या के साथ, heal, attack, shield, और farm।

दूसरा तर्क आपके अलावा अन्य सभी जीवित बॉट्स का एक फेरबदल सरणी है, जिसे एक गुण वाली वस्तु के रूप में स्वरूपित किया गया है uid, hp(प्लस शील्ड) worth, और attack(हमला स्तर)। तीसरा तर्क एक खाली वस्तु है जिसका उपयोग टर्न-टर्न स्टोरेज के लिए किया जा सकता है।

उदाहरण बॉट:

यह बॉट तब तक खेती करेगा जब तक यह अपने हमले को 5 के स्तर तक अपग्रेड नहीं कर सकता है, तब तक प्रत्येक बारी में एक यादृच्छिक बॉट पर हमला करता है जब तक कि वह मर नहीं जाता (या जीतता है)। उपचार / परिरक्षण की कमी के कारण बहुत प्रभावी नहीं है।

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

इस बॉट में दो मोड हैं: आक्रामक और रक्षात्मक। यह रक्षात्मक मोड में या तो एक यादृच्छिक बॉट या चंगा करेगा, और यह आक्रामक मोड में होने पर या तो हमला करेगा या ढाल देगा। यह जब भी संभव होगा अपने हमलों को उन्नत करने का प्रयास करेगा।

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

नियम:

मानक Loopholes निषिद्ध
बॉट्स अपने दायरे से बाहर किसी भी चर को पढ़, संशोधित या जोड़ नहीं सकते हैं, धोखा देने का प्रयास नहीं कर सकते हैं, और किसी भी नियंत्रक-परिभाषित या DOM कार्यों को नहीं कह सकते हैं।
वापसी मान गलत होना चाहिए, या उपरोक्त फ़ंक्शन आउटपुट में से एक होना चाहिए
बॉट्स को एक विशिष्ट बॉट को लक्षित करने के लिए डिज़ाइन नहीं किया जाना चाहिए, लेकिन आम रणनीतियों का लाभ उठाने के लिए डिज़ाइन किया जा सकता है
बॉट्स खुद पर हमला नहीं कर सकते (@Ness द्वारा टिप्पणी के कारण खोजा गया)
बॉट्स को किसी भी अन्य बॉट्स से पर्याप्त रूप से अलग होना चाहिए कि उन्हें यथोचित रूप से अलग एंट्रीज माना जा सके
अब टीम बनाने की अनुमति नहीं है
नियंत्रक यहां पाया जा सकता है
गपशप करने का कमरा

नए नियंत्रक डिबगिंग:

फ़ाइल का उपयोग करके gold-battle-log.js, आप debugएक बॉट की संपत्ति का मान botData0 (कोई लॉगिंग), 1 (लॉग चाल), या 2 (लॉग चाल, एचपी, सोना, स्तर, आदि) निर्धारित कर सकते हैं।

शुक्रवार, 9 अगस्त को 1700 यूटीसी पर चुनौती समाप्त होती है

king-of-the-hill javascript

— Redwolf कार्यक्रम
स्रोत

4

सभी बॉट्स के साथ एक जिस्ट बनाया। gist.github.com/Draco18s/2efbf95edcf98d6b1f264e26bb669d1 मैं इसे अपडेट रखने का प्रयास करूंगा (लेकिन अगर यह एक अच्छी शुरुआत नहीं है)।

— ड्रेको 18s 14

4

बॉट के साथ ऑटो- अपडेटिंग

— Redwolf Programs

4

मैं इस प्रश्न को बंद करने के लिए मतदान कर रहा हूं क्योंकि यह पहले से ही नए उत्तरों के लिए बंद है ("यह चुनौती समाप्त हो गई है। अंतिम स्कोर देखने के लिए ...")

— अपराह्न

3

क्या आप नहीं कर सकते? मैं गैर-प्रतिस्पर्धी उत्तरों के साथ ठीक हो जाऊंगा, और [closed]अंत में आकस्मिक दर्शकों को मेरी चुनौती को पढ़ने के बाद छोड़ देने की संभावना है, क्योंकि यह कम गुणवत्ता वाला या ऑफ-टॉपिक है।

— रेडवॉल्फ कार्यक्रम

5

@pppery मैंने आज तक समाप्त होने के लिए एक चुनौती को बंद होने के बारे में कभी नहीं सुना है, और मैं उस सामाजिक प्रतिबंध का तर्क दूंगा जिसे आप लागू करना चाहते हैं वह भी मौजूद नहीं है। इसे बंद करने की कोई आवश्यकता नहीं है, और मैं इसे बंद नहीं करना चाहता। मेरे लिए, ऐसा लगता है कि साइट की भलाई के बजाय, समापन के लिए बंद होना चाहिए। यदि कोई किसी पुराने प्रश्न का उत्तर पोस्ट करना चाहता है, तो उन्हें सक्षम होना चाहिए। गंभीर दावेदार नियम के बाद यह कहने पर कोई ध्यान नहीं है कि यह पोस्ट होने पर एक गंभीर दावेदार होना है; एक जवाब अभी भी चुनौती के लिए एक गंभीर दावेदार हो सकता है, भले ही यह जीतने का दावेदार न हो

— Redwolf Programs

16

unkillable

अंडरएबल से कांटा ।

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

उन्नयन की घातीय लागतों को देखते हुए, यदि हम उपचार को उन्नत नहीं कर सकते हैं तो खेती को उन्नत कर सकते हैं, जिससे बॉट सोने को अधिक कुशलता से एकत्र कर सके।

— Draco18s
स्रोत

मेरे परीक्षणों में प्रतियोगिता को बिल्कुल कुचल दिया

— रेडवॉल्फ प्रोग्राम्स

1

मुझे लगता है कि यह बॉट थोड़ा मजबूत हो सकता है कि पहले ifबयान का इस्तेमाल किया गया था <=- वर्तमान में यह कभी भी पूरा नहीं करेगा।

— 13

@Scoots यह निश्चित नहीं है कि यह कितना मायने रखेगा, लेकिन मैं इसे बदलूंगा।

— ड्रेको

2

@ Draco18s मुझे यकीन है कि यह बहुत कम मायने रखता है - लेकिन क्या यह साइट छोटे से व्यावहारिक रूप से बेहूदा सुधारों के बारे में नहीं है? :)

— स्कूटर

@Scoots हीलिंग से अधिकतम स्वास्थ्य इस चुनौती में ज्यादा मायने नहीं रखता है क्योंकि वास्तविक हमलावर खतरे नहीं हैं। केवल वास्तव में आक्रामक बोट बुलबोट है, और आप वास्तव में उसके बारे में कुछ नहीं कर सकते। यह वास्तव में पूर्ण स्वास्थ्य पर रहने के लिए प्रदर्शन को कम कर सकता है।

— 14

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

बहुत सारे बॉट हैं, चारों ओर सोने के लिए पर्याप्त नहीं है। यह बॉट एक समाधान का प्रस्ताव करता है।

नरसंहार, हाँ, लेकिन यादृच्छिक, फैलाव, अमीर और गरीब के लिए समान।

उन्होंने उसे पागल कहा।

थानोसबॉट बॉट समुदाय के लिए सबसे अच्छा चाहता है, और सभी तरह से जाने के लिए तैयार है। शुरुआत में, वह अपने हमले, खेती और हीलिंग को अधिक कुशलता से संसाधनों को इकट्ठा करने और लड़ाई जीतने के लिए अपग्रेड करेगा। आगामी लड़ाईयों के लिए, संसाधनों को इकट्ठा करते हुए, वह अनियमित रूप से लोगों पर हमला करना शुरू कर देगा। वह अपनी सेना, अपने हथियारों और खुद में सुधार करता रहेगा।

एक बार आबादी का 50% समाप्त हो जाने के बाद, पैदा होने वाले बॉट केवल पूर्ण घंटी और स्पष्ट आसमान को जान पाएंगे, वह खेती के जीवन में रिटायर हो जाएगा, और एक आभारी ब्रह्मांड पर सूरज उगने को देखेगा। वह पूरी तरह से शांतिवादी बन जाएगा, केवल सब्जी सूप और खेती के साथ खुद को ठीक करेगा।

— काइतो बच्चा
स्रोत

6

मैं "हमला" का नाम बदलकर "स्नैप" करने के लिए

— ललचा

11

चुराने वाले को मार डालो

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

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

  let shp = shld+hp;

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

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

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

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

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

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


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



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

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

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


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

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

अब न केवल चोरी करता है, बल्कि चोरी भी मारता है!

यह बॉट खेत को छोड़कर ज्यादा कुछ नहीं करता है, और जब यह संभावना को नोटिस करता है, तो एक मरने वाले दुश्मन को अंतिम झटका देने में शामिल होता है, और किसी तरह बहुत अच्छा होने का प्रबंधन करता है।

— dzaima
स्रोत

यह काम करता है क्योंकि एक हत्या के झटका में शामिल सभी बॉट्स को पूर्ण इनाम मिलता है।

— Draco18s

@ Draco18s मैं समझता हूं कि यह अच्छा क्यों हो सकता है, मुझे बस इस तरह के एक सरल विचार की उम्मीद नहीं थी कि औसत 2x पर अगले सर्वश्रेष्ठ बॉट का स्कोर मिल जाए (इसे बनाने के समय)।

— dzima

हेहे, यह उचित है। मुझे सभी बॉट्स को डाउनलोड करना होगा जब मैं कर सकता हूं और देख सकता हूं कि क्या मैं दूसरा समाधान पा सकता हूं।

— ड्रेको

9

द इक्वलाइज़र

यह बॉट, बॉट समुदाय में शांति बहाल करना चाहता है। वह लगातार सबसे अधिक हमले के साथ बॉट्स को निशाना बनाता है, केवल यह देखते हुए कि अगर बॉट की हीलिंग उसके अपने हमले से बेहतर है। एक बार जब इसके हमले से बदतर चिकित्सा वाले कोई बॉट्स नहीं बचे, तो वह शांतिपूर्ण खेती के जीवन में सेवानिवृत्त हो जाएगा।

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

— B0RDERS
स्रोत

8

आशावादी

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

यह मान लेता है कि वह अपना 80% समय शांति से खेती में खर्च कर पाएगा, इसलिए वह खेती को अधिकतम करने से शुरू होता है, और उसके बाद ही अपने युद्ध कौशल पर ध्यान देना शुरू करता है। निश्चित रूप से कुछ भी गलत नहीं होगा!

— histocrat
स्रोत

8

की सहायता को मार

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

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

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

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

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

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

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

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

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

  return farm();
}

जब आप पलक का नुकसान कर सकते हैं और फिर भी पूरा क्रेडिट प्राप्त करते हैं तो अपग्रेड अटैक वैल्यू क्यों?

किल स्टीलर से एक बार फिर से गुल्लक की ओर लौटते हैं। मैं कोड के कई ब्लॉकों को सरल बनाने में सक्षम था जहां कथन हमेशा सच थे और कुछ संख्याओं के साथ बेला हुआ था जिसके परिणामस्वरूप मूल पर बड़े पैमाने पर लाभ हुआ था।

मुझे @dzaima को यह बताने के लिए हाथ लगाना होगा कि तेजस्वी एक धनी प्रतिद्वंद्वी है जो एक हत्या होने से पहले मदद की बारी में शामिल होने की संभावना रखता है। कुछ Stun()में से एक (बहुत) एक सकारात्मक परिणाम है। एक बार फिर मैं इस विचार में सुधार करने में सक्षम था, यह जानते हुए कि किल स्टीलर इसी तरह के तर्क चला रहा होगा, किल असिस्ट एक "दूसरा सबसे अच्छा" लक्ष्य (कुछ विवेक के साथ) की तलाश में है और इसके बजाय उन्हें अचेत करता है।

माइनर अपडेट बॉट-बॉट-टू-डाई को तेजस्वी और तेजस्वी बॉट को रोकने के लिए-सबसे-संभावना-बनाने-मारने के लिए।

नमूना परिणाम (1000 खेलों के बाद शीर्ष 5 को काट दिया गया)

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

— Draco18s
स्रोत

ठहरिए, किस किसान को किस देश में 14k सोना मिलता है?

— रेडवुल्फ प्रोग्राम्स

यह एक:runGame(1) results: [...] captFarmer: 13768

— Draco18s

यह अप्रत्याशित रूप से बहुत अधिक है ... यह आम तौर पर मेरे परीक्षणों में 10k के आसपास हो जाता है

— Redwolf कार्यक्रम

* श्रुघ * कोई विचार नहीं। मैं सबकुछ साफ करने के लिए एक स्वचालित जाइस्ट अपडेट करूंगा।

— ड्रेको 18s

समय सीमा के अंत तक मेरा पसंदीदा बॉट।

— 02

7

अनडीबल बॉट (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()
            }
        }        
    }   
}

— लुइस फेलिप डी जीसस मुनोज
स्रोत

बुरा मत मानना ... मैं यह उधार लेने जा रहा हूँ।

— ड्रेको

6

PatientStrategistBot

मैंने एक बॉट लिखने की कोशिश की, जो जरूरत के अनुसार तैयार करना और बचाव करना शुरू कर देता है और फिर खेल में अन्य उच्च मूल्य बॉट को मारने के लिए स्विच करता है।

वर्तमान में यह ठीक से काम नहीं करता है क्योंकि इसकी या तो गेम की शुरुआत में हत्या-बॉट्स के एक गिरोह द्वारा मार दी गई है या अपने आक्रामक मोड में कहीं फंस गया है।

फिर भी यह मेरा पहला 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();

}

— निकोलाई
स्रोत

6

स्विट्जरलैंड

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

जैसा कि नाम से पता चलता है, यह बॉट ज्यादातर तटस्थ (अब यह मरने वाले बॉट्स को मारने में मदद करता है) ~~तटस्थ है~~ और बस खेतों और चंगा, धीरे-धीरे अपने सोने का निर्माण ( ~~स्विट्जरलैंड की तरह~~ )

— SuperStormer
स्रोत

6

द बॉट दैट फार्म्स, अटैक्स, शील्ड्स, एंड हील्स हील्स बट नेवर स्टन्स

^{(संक्षिप्त नाम TBTFASAEHBNS है , 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();
}

यह बॉट मूल रूप से:

शुरू में खेती पर बनाता है
जरूरत पड़ने पर खुद का बचाव करता है
हमलों जब यह मार सकता है या जब यह सोचता है कि किसी को मारने का मौका है
यहाँ और फिर उन्नयन
बाकी समय खेतों में
कभी अचेत नहीं हुआ

संपादन 1: एक मुद्दा तय किया और बहुत सारे गेम के साथ परीक्षणों के आधार पर बॉट में कुछ छोटी चीजों में सुधार किया।

संपादित 2: ढाल उन्नयन को कम किया।

— Night2
स्रोत

2

जैसे ही मैंने नाम देखा, मुझे पता था कि यह आपका बॉट होगा:

— रेडवुल्फ प्रोग्राम्स

मुझे लंबे नामों के बारे में खेद है, लेकिन मैं इसका आदी हूं!

— Night2

1

शायद यह एक अच्छे बॉट का संकेत है ... मेरे परीक्षण यह 5 वें स्थान पर

— दिखाते हैं

5

SniperBot

यह बॉट केवल तभी प्रभावी होगा जब कोई ऐसे बॉट को जोड़ना शुरू कर देगा जो वास्तव में नियमित आधार पर हमला करते हैं। SmartFarmer मेरा वर्तमान अनुकूलित समाधान है

एक गोली मार सकता है अगर चंगा
अगर 30 से कम है तो चंगा
बॉट पर हमला करता है अगर इसे उठा सकते हैं और खेती से अधिक पैसा कमा सकते हैं
अगर खर्च हो सकता है तो खेती को उन्नत करें
अगर स्वास्थ्य 80 से कम है और इसे वहन किया जा सकता है, तो उपचार को अपग्रेड करना
खेतों

गिद्धों को हमले की जरूरत नहीं है

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

— B0RDERS
स्रोत

अनपेक्षित पहचानकर्ता ( int) लाइन 2 पर। संदर्भ: स्वास्थ्य: स्वास्थ्य परिभाषित नहीं है।

— ड्रेको

होना चाहिए me.hp?

— mbomb007

माफ़ करना। जावास्क्रिप्ट के लिए नया। मदद के लिए धन्यवाद

— B0RDERS

आपकी if(me.hp <30 && ...)बात को ठीक करने के लिए एक बेतुके स्तर की जरूरत के आधार पर सिर्फ पहले खंड को सरल बनाया जा सकता है (lvl 65)

— Veskah

@Veskah कि बाहर इशारा करने के लिए धन्यवाद। उस समय से एक अवशेष था जब न्यूनतम hp अधिक था

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

बुलीबोट का मैशअप और कुछ अन्य बिट्स। ऑप्टिमिस्ट ने एक छोटा और मीठा अवसरवादी हमला किया था, जो मैंने इशारा किया था (हालांकि अन्य बॉट भी इसी तरह की गणना करते हैं)।

उन्हें तेजस्वी द्वारा लक्ष्य को धमकाने के बजाय, यह उनकी मीठी, मीठी लूट के लिए हत्या कर देता है। यह बदमाशी के लिए झुंड में सबसे कमजोर लोगों को भी निशाना बनाता है, लेकिन यह सबसे कमजोर लक्ष्य एचपी बहुत अधिक होने पर खेती छोड़ देगा।

— Draco18s
स्रोत

आप खुद को मौत के घाट उतार रहे हैं। मेरा संपादन स्वीकार करें :)

— B0RDERS

1

@AndrewBorders हा, इसके बारे में भी नहीं सोचा था। धन्यवाद।

— Draco18s

यह बॉट महान था जब तक कि रक्षक बॉट चारों ओर नहीं आए।

— 19

@ B0RDERS शील्ड बहुत मजबूत है, भले ही यह समय बर्बाद करता है।

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

अधिकतर आक्रामक बॉट। इस तथ्य से बहुत परेशान है कि यह वास्तव में FizzBuzz नहीं कर सकता है, इसलिए यह इसके बजाय सिर्फ गुस्से में बज़ करता है। जब यह फ़िज़िंग या बज़िंग नहीं होता है, तो यह 30 बॉट पर 30 घुमावों तक दूर हो जाता है और प्रगति नहीं होने पर किसी अन्य बॉट को निशाना बनाने के लिए छोड़ देता है।

~~असाधारण रूप से असंगत प्रदर्शन करता है।~~ कोई बात नहीं, कंट्रोलर को अपडेट कर दिया, अब लगता है कि यह हमेशा पैक के बीच में होगा।

— रिन के फूरियर रूपांतरण
स्रोत

मुझे यह अवधारणा पसंद है। मौजूदा स्थिति के बावजूद, यह अपनी गति से साथ-साथ चलता रहता है।

— नेस

5

bullyBot

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

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

    return stun(storage.bullyTarget);
}

इसे ऑनलाइन आज़माएं!

जीत नहीं सकते लेकिन निश्चित रूप से अपने लक्ष्य को या तो सुनिश्चित करने के लिए अपने दम पर कोशिश करेंगे। bullyBot पहले मोड़ पर भी आगे बढ़ता है ताकि अगर कोई बाहरी प्रभाव न हो, तो वह अपने लक्ष्य को 5-0 से हरा देगा या उन्हें 5-5 से हरा देगा।

— Veskah
स्रोत

5

JustFarm

मुझे लगा कि मैं सरल शुरुआत करूंगा।

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

— गुमनाम
स्रोत

13

यह बॉट खेती की 2HP लागत के कारण आत्महत्या कर लेगा।

— ड्रेको

@ Draco18s हालांकि बॉट्स की संख्या के आधार पर राउंड इससे पहले समाप्त हो सकता है

— Redwolf प्रोग्राम्स

1

जबकि तकनीकी रूप से सच है, डिफ़ॉल्ट अंत समय 1000 होने पर एक 50 राउंड टाइमर बहुत कम होता है।

— ड्रैक 18s

इसने दो उदाहरण बॉट को हराया, लेकिन अब कुछ और प्रस्तुतियाँ हैं जिन्हें मैं कुछ बेहतर करने की कोशिश कर सकता हूं।

— अनाम

@ अनाम शायद हीलिंग और खेती के उन्नयन सहित पर्याप्त होगा। चूँकि सबसे अधिक सोना पाना ही अंतिम लक्ष्य होता है, यह देखते हुए कि बॉट की मुख्य नौकरी काम कर सकती है। अब तक कोई बॉट नहीं हुआ है, जिसमें "मोड" है जैसे

— हील

4

मेहतरबोट (V2)

एहसास हुआ कि यह पहले एक मेहतर की ज्यादा नहीं थी। नई रणनीति तब तक इंतजार करती है जब तक कि वह दूसरे बॉट को नहीं मार सकती। यदि किसी की हत्या नहीं की जा सकती है, तो वह ढाल बनाकर बैठता है।

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

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

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

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

— reffu
स्रोत

1

me.levels.attacl?

— ५२ पर ड्रेको १18

अच्छी पकड़, निश्चित

— reffu

4

उदासीन

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

मूडी की डिफ़ॉल्ट रणनीति कुछ समय के लिए खेती और चिकित्सा को उन्नत करना है, फिर अन्य बॉट्स को मूल्य के अवरोही क्रम में बाहर निकालना है। हालांकि, अगर यह हमला हुआ है, तो यह थोड़ा डर जाएगा और थोड़ी देर के लिए उपचार पर वापस लौट जाएगा। यदि यह हमला करता है और "विफल" होता है, क्योंकि पीड़ित हमले की तुलना में अधिक प्रभावी ढंग से उपचार या परिरक्षण कर रहा था, तो यह गुस्सा हो जाएगा और अपनी हमलावर क्षमताओं को अपग्रेड करने के लिए बंद हो जाएगा।

— histocrat
स्रोत

4

डाकू

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

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

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

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

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

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

सुदृढीकरण सीखने वाले बॉट में पहला प्रयास। विशुद्ध रूप से रक्षात्मक के लिए अब खोज स्थान को कम करना। फ़िज़बज़्ज़ के एक चतुर स्पिनऑफ़ की तरह - यह बार-बार पांच क्रियाओं की एक विशिष्ट श्रृंखला को दोहराता है; पाँच क्रियाएं आरएल द्वारा चुनी गई हैं।

लेकिन यह अभी के लिए ज्यादातर गणना पर आधारित है - मैंने सिर्फ 3 ^ 5 = 243 पांच रक्षात्मक कार्यों की श्रृंखला के क्रमपरिवर्तन को उत्पन्न किया जो खुद को बार-बार दोहराते हैं, और औसत लाभ प्राप्त करने के लिए अपने औसत स्कोर (200 से विभाजित) को संग्रहीत करते हैं storage.priorसरणी में 100 से अधिक पुनरावृत्तियों पर पांच मोड़) । फिर, खेल के दौरान, यह उन स्कोर सूचियों को अद्यतन करने के लिए एक एप्सिलॉन-लालची दृष्टिकोण को लागू करता है ताकि यह भविष्य में अधिक प्रूफ हो। (यह भी क्योंकि एप्सिलॉन = 0.3 का उपयोग करने से एप्सिलॉन = 0.1 की तुलना में बेहतर होता है इसलिए मैंने इसे अभी रखा है।)

यह ठीक करता है, लगातार मेहतर और ऑप्टिमिस्ट के बीच रखता है। मैं वर्तमान में वास्तविक खेलों पर कुछ और प्रशिक्षण कर रहा हूं, और रणनीति को फ्रेम करने के बेहतर तरीके तलाश रहा हूं, यह देखने के लिए कि क्या मैं इसे सुधार सकता हूं।

— रिन के फूरियर रूपांतरण
स्रोत

4

अवसरवादी

यह एक कुछ अन्य लोगों (विशेष रूप से स्कैवेंजरबॉट (V2) और अनकिल) से थोड़ा उधार लेता है क्योंकि उनके पास समान विचार थे जो मेरे मन में थे, लेकिन मैं आमतौर पर अच्छी तरह से गोल-गोल और जैक-ऑफ-ऑल-ट्रेडों को केवल ध्यान केंद्रित करने से अधिक पसंद करता हूं एक या दो चीजें। इसका मतलब यह होगा कि मैं जीत नहीं पाऊंगा, लेकिन यह कहीं न कहीं बीच में होना चाहिए (जो कई चीजों में ज्यादातर समय मेरे साथ होता है)।

तो यह रसदार हत्या को चुराता है; यदि आवश्यक हो तो चंगा करता है; उस क्रम में खेत, हमले और चंगा को अपग्रेड करना; और खेतों अन्यथा।

function Opportunist(me, others, storage) {

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

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

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

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

— नेस
स्रोत

1

2 तर्क होना चाहिएothers

— सुपरस्टॉर्मर

4

ScaredBot

यह अन्य बॉट पाता है:
- उच्चतम हमले के साथ
- अधिकांश धन और एचपी खुद के हमले से कम है
यदि इसका एचपी + शील्ड पाया की तुलना में कम है highest attack * (25% of bots), या इसके निचले छोर के पास है HP + shield, तो यह ढाल देता है
यदि उसे अपने हमले की तुलना में कम ढाल वाला एक बॉट मिला, तो यह उस पर हमला करता है।
यदि इसका स्वास्थ्य है < 50, तो यह ठीक हो जाता है।
यदि यह किसी भी ढाल, हील और खेत को अपग्रेड कर सकता है, तो यह सबसे निचले स्तर के साथ एक को अपग्रेड करता है
यह खेतों

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

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

यह विचार सबसे लंबे समय तक जीवित रहने का है और अन्यथा अपग्रेड करने में सक्षम होने के लिए सुरक्षित और सस्ते तरीके से सोने की कोशिश करें।

अपग्रेड की प्राथमिकताओं को संभवतया ट्विक किया जाना चाहिए, साथ ही साथ यह भी निर्धारित करना चाहिए कि क्या ढाल के लिए निर्धारित करते समय।

— user24343
स्रोत

3

SmartFarmer

खेतों, उन्नयन खेती, कम स्वास्थ्य अगर चंगा। वास्तव में आक्रामक बॉट्स आने तक खेती अत्यधिक प्रबल थी। अब मेरा बॉट मार दिया जाता है :-(

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

— B0RDERS
स्रोत

1

मैं अनिवार्य रूप से एक ही रणनीति का परीक्षण कर रहा था कि यह देखने के लिए कि अधिकतम प्राप्य मूल्य क्या है और सबसे अच्छी संख्या जो मुझे मिल सकती है, वह यह है कि हील अपग्रेड होने पर थोड़ी देरी हो रही है (मैंने सोने का इस्तेमाल किया = लागत * 2) और lvl10 हील तक जा रहा है ।

— निकोलई

यह मूल्य गुणक एक अच्छा विचार है। मैंने भी कुछ ऐसा ही जोड़ा। मुझे यह देखने में दिलचस्पी होगी कि आपको कौन से नंबर मिले हैं

— B0RDERS

3

रंडी

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

प्रत्येक मोड़, खेती और हीलिंग के लिए प्रत्येक बॉट को मारने के परिशोधित लाभ की तुलना करता है और सबसे अच्छा विकल्प चुनता है। वास्तव में यह पता लगाने के लिए राज्य का उपयोग करना चाहिए कि किसी बॉट को मारने में कितना समय लगेगा, लेकिन अभी के लिए यह हर बॉट को ठीक करता है या औसतन 5 अंक का नुकसान देता है और अन्य बॉट को नुकसान पहुंचाता है।

— histocrat
स्रोत

3

अनुकूल बॉट

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

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

  // keep farming
  return farm();
}

others[0].hpहै hp + shieldबजाय hp...

— TSH
स्रोत

4

क्या कोई मुझे अंग्रेजी में फ़ंक्शन नाम का अनुवाद करने में मदद कर सकता है? ^ _ ^

— tsh

4

Google Translate के अनुसार, "闷声发大财" का अर्थ है "Muffled"। बहुत यकीन है कि आप क्या चाहते हैं और वास्तव में अभी तक एक और Google अनुवाद महाकाव्य विफल नहीं हुआ है ... मैंने आगे खोज की और सभी परिणामों का उल्लेख है कि कोई भी अंग्रेजी शब्द नहीं है जिसका उपयोग यहां किया जा सकता है, इसलिए इसे रखने के लिए बेहतर हो सकता है वास्तव में, जैसा कि यह एक चीनी उपसर्ग लगता है कि आम तौर पर इसका मतलब है कि किसी को चुपचाप काम करना चाहिए और परिणामों को अपने लिए बोलना चाहिए और एक पारंपरिक दर्शन को प्राप्त करना चाहिए। दुर्भाग्य से, मैं चीनी को सीधे अनुवाद करने के लिए बिल्कुल नहीं जानता। : D

— आउटगोल्फर

1

एक मूल चीनी वक्ता के रूप में, इसका अर्थ है "चुपचाप एक बहुत बड़ा भाग्य बनाना": v conn यह भी जानबूझकर चुप होने का अर्थ है, शाब्दिक रूप से "ध्वनि को ढंकना"

— रिन का फूरियर

1

ख़ुशामदी? रडार के अंतर्गत? DontMindMe? AttentionDeflector?

— पीटर टेलर

3

लेखपाल

यह व्यावहारिक बॉट सबसे अधिक आर्थिक रूप से लाभकारी कदम की गणना करता है, लेकिन वह अपने हमले के प्रोफाइल को कम रखने के लिए पसंद करता है ताकि सभी सतर्क बॉट्स से परेशानी से बचा जा सके। वह रक्षात्मक मदद लेने या उन पर शिकार करने की कोशिश नहीं करता है। बल्कि, वह वही करता है जो उसे सबसे ज्यादा मदद करता है।

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

— B0RDERS
स्रोत

3

reallyCommittedTurtle

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

ये रही चीजें। यह वास्तव में खतरनाक हो गया है। सभी पर खेती करने से आपका मूल्य बढ़ता है, जिससे आप लक्ष्य बनाते हैं। इसलिए यह वास्तव में खेती करने के लिए सुरक्षित नहीं है जब तक कि आप एक विशाल ढाल का निर्माण नहीं करते हैं और सभी हिंसा नीचे मर गई हैं। तब आप अपने सिर को अपने खोल से बाहर निकाल सकते हैं और खेती शुरू कर सकते हैं। या मारना-मारना। जो भी बेहतर भुगतान करता है।

— histocrat
स्रोत

2

अभिभावक

मेरे पास एक से अधिक सबमिशन हो सकते हैं, है ना?

कैंपबोट का एक कांटा। हमला करने पर ध्यान केंद्रित करने के बजाय ढाल नहीं करता है। कैंपबोट जैसे यादृच्छिक पर हड़ताली के बजाय उच्च हमले के आंकड़ों के साथ खिलाड़ियों पर हमला करने के लिए एक वरीयता दिखाता है। चिकित्सा के बजाय इसकी खेती को उन्नत करने पर ध्यान केंद्रित करता है।

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

— गुमनाम
स्रोत

मेरा बॉट यादृच्छिक रूप से हमला नहीं करता ...

— सुपरस्टॉर्मर

आप जितनी बार चाहें उतनी बार पोस्ट कर सकते हैं, जितना अधिक मैं

— मानता

@SuperStormer मुझे पता है कि तुम्हारा पूरी तरह से यादृच्छिक नहीं है, लेकिन:let victim=potentialVictims[Math.floor(Math.random()*potentialVictims.length)]

— बेनामी

लेकिन यह पहले उन लोगों को

— छानता है

जब आप इसे पोस्ट करते थे तो मैं बराबरी के नाम वाले बॉट पर काम कर रहा था। मैं अभी भी इसे ठीक कर रहा हूं, लेकिन मुझे आपके कुछ विचार पसंद हैं।

— B0RDERS

2

Rando

यह मूर्खतापूर्ण व्यक्ति कुछ पूर्वाग्रहों के साथ समान यादृच्छिकता के आधार पर कार्रवाई का चयन करेगा। यदि एक बेतरतीब ढंग से चुनी गई कार्रवाई काम नहीं करेगी, तो यह अगली पसंद तक कम हो जाती है।

तो औसतन, उसे समय के लगभग 2/9 पर हमला करना चाहिए और उस समय के लगभग 3/9 भाग पर। बाकी लगभग 1/9 मौका है अगर वह अपग्रेड करने में सक्षम है, या यदि उपचार / परिरक्षण इसके लायक है, आदि।

वह संभवतः अच्छा प्रदर्शन नहीं करेगा, लेकिन कम से कम एक मौका है कि वह सर्वोच्च शासन करता है। और यही रैंडो का पूरा उद्देश्य है। उसे सिर्फ स्वयं पर विश्वास करना है! उसके सामने सभी विकल्प रखे गए हैं। उसे केवल वही चुनना चाहिए जो किसी भी स्थिति के लिए आवश्यक हो।

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

(मुझे पता है कि "डिफ़ॉल्ट" अनावश्यक है, लेकिन मुझे लगता है कि यह मजबूत कोड के लिए अच्छा कोडिंग अभ्यास है।)

— नेस
स्रोत

2

"उसे बस खुद पर विश्वास करने की ज़रूरत है" ... मैं अभी बहुत हंस रहा हूं

— रेडवॉल्फ प्रोग्राम्स

2

बॉट को मार डालो

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

    storage.hp = me.hp;

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

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

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

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

एक साधारण बॉट, किल बॉट सिर्फ अपने दुश्मनों को मारना चाहता है। चूंकि परिरक्षण उपचार की तुलना में बहुत अधिक कुशल है (विशेषकर जब समतल किया जाता है), तो बॉट बॉट हमेशा जब भी हमला किया जाता है, तो हमेशा परिरक्षण द्वारा एक अनपेक्षित लक्ष्य होने की कोशिश करता है। किल बॉट यहां के आसपास कमजोर, शांतचित्त बॉट्स के बीच काफी अच्छी तरह से करता है (आप उनके लिए इसे महसूस कर सकते हैं)।

— Spitemaster
स्रोत

3

ध्यान दें कि o.attackहमला स्तर है, इसकी क्षति नहीं

— रेडवुल्फ प्रोग्राम्स

2

फार्महेल बॉट

@Anonymous 'JustFarm bot से कांटा

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

— maninthecomputer
स्रोत

2

अक्षय

Draco18 के बॉट का एक संशोधन, ढाल का उपयोग करना (अन्य बॉट्स के खिलाफ अधिक प्रभावी)

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 कार्यक्रम
स्रोत

गोल्ड बैटल KoTH

unkillable

ThanosBot

चुराने वाले को मार डालो

द इक्वलाइज़र

आशावादी

की सहायता को मार

अनडीबल बॉट (v3)

PatientStrategistBot

स्विट्जरलैंड

द बॉट दैट फार्म्स, अटैक्स, शील्ड्स, एंड हील्स हील्स बट नेवर स्टन्स

SniperBot

BullyDozerBot

FizzBuzz

bullyBot

JustFarm

मेहतरबोट (V2)

उदासीन

डाकू

अवसरवादी

ScaredBot

SmartFarmer

रंडी

अनुकूल बॉट

लेखपाल

reallyCommittedTurtle

अभिभावक

Rando

बॉट को मार डालो

फार्महेल बॉट

अक्षय