Bu zorlu mücadelede, savaşta diğer bütün dostlukları yenmek amacıyla bir Burs oluşturacaksınız .

Bir arkadaş grubu (takım) 3 karakterden oluşmaktadır . Her karakter, ekibinin geri kalanından bağımsız hareket eder, ancak düşmanınızla savaşırken birlikte çalışması gerekir. Takımlar birbirleriyle yüz yüze dönecek şekilde döner. Galibiyetler 3 puan, bağlar 1 puan, kazançlar ise 0 puandır.

Karakterlerin Yetenekleri var. Karakterlerinizin hangi yeteneklere sahip olduğunun seçimi, bu KotH'deki en önemli (ve eğlenceli) bölümlerden biridir . Hepsi güçlü ve düşmanınızı yok etme potansiyeline sahip.

Karakterlerde Sağlık Puanı (HP) vardır ve HP'leri çarptığında (veya altına düştüğünde) 0, ölürler . Rakibinin takımındaki tüm karakterler ölürse, sen kazandın!

Karakterlerde Mana var. Eylemlerin çoğu Mana'nın gerçekleştirmesini gerektirir ve eğer yeterli paranız yoksa, bu işlem sizin için uygun değildir.

Karakterlerin Dönüş Gecikmesi var . Bu, her bir tur arasındaki tik sayısını belirler (100'de başlar). Alçak daha iyi.

Karakterlerin özellikleri var . Her karakter, her bir nitelikte 5 tabanına sahiptir ve bölmek için 20 ek özellik puanı verilir. Özellik noktaları atadıktan sonra, birincil niteliğiniz en yüksek niteliğiniz olarak ayarlanır.

Mevcut özellikler:

• Güç: Tur başına 10 Max HP ve .5 HP verir
• Zeka: Tur başına 7 Max Mana ve .1 Mana verir.
• Çeviklik: Dönüş Gecikmesini 1'e Düşürür

Hareket, Vizyon, Menzil
Aralıkları aşağıdaki gibidir (0 merkezli). Bazı aralıklar kardinaldir , yani yalnızca doğrudan yukarı, sola, sağa veya aşağı gidebilirler.

    444
   43334
  4322234
 432111234
 432101234
 432111234
  4322234
   43334
    444

Karakterlerin başlangıç ​​vizyonu 2'dir. Aynı dostluktaki oyuncular arasındaki vizyon paylaşılır.

Nasıl oynanır

İnşaat
Oyuncuları arkadaşlıklarını kuracak. Aşağıdaki adımları yapmanız gerekir :

1. Her karaktere nitelik puan verin . Her karakter her statta 5 ile başlar, 3 arasına dağıtılacak ek 20

2. Her karaktere yetenekler ver . Her karakter 4 yetenek slotu ile başlar ve yetenekler varsayılan olarak 1 slot alır. Bazı yetenekler tekrarlanabilir ve bir karaktere birden çok kez verilebilir. Sahibin izni olmadan başka bir gönderim yapma kabiliyetini kullanmak yasaktır.

3. Botların için biraz kod yaz . Kodun Java'da olması gerekir ve mücadele için kullanılacaktır (bir sonraki adım)

Eylemler

Tüm karakterler 3 standart işlemle başlar:

1. Adım : Karakterinizi 1'in kardinal aralığında taşıyın
2. Dilim : Bir kardinal aralığında PrimaryAttribute için bir düşmana saldır
3. Smile : Hiçbir şey yapma

Bir karakter sırasına göre, gerçekleştirmek için bir eylem seçmelisiniz. Eylemler bir Mana maliyetine sahip olabilir ve bu işlemi tekrar gerçekleştirmeden önce beklemeniz gereken dönüş sayısını tanımlayan bir Cooldown olabilir.

Yetenekler
Her karakterin 4 yetenek yuvası vardır. Bir yetenek italik ise, bu bir eylemdir.

Yetenekleri

İsim Tanım Mana Cooldown 
                                                     Hareketlilik                                                     

Blink         bir kare taşı, aralık 4 2 2 
 Swap          Target ile takas yerleri 5 5 
 Teleport      20 5 yerde Taşı

Dash Adım aralığını 1 arttırın. Tekrarlanabilir                                               
Mobil Adım 8 yönden herhangi birinde hareket edebilir                                                  
                                                    saldırma                                                    

Hızlı         Dilim iki kez 3 0 
 Dokuma         Görünen tüm düşmanları bir kez dilimleyin 15 10

Alınan Her Dilim, hedefinizin birincil özelliklerinden birini çalar. 20 dönüş sürer                    
Cleave Her Dilim bitişik düşmanlara 1/2 hasar verir                                           
Kritik Dilime% 200 hasar vermesi için% 30 şans ekler. tekrarlanabilir                               
Her Dilimde Ziyafet, HP'nizi 3 artırır. Tekrarlanabilir                                             
Esnek 8 yönden herhangi birinde Dilimleyebilen Kutu                                                      
Mana çalmak dilim 2 mana çaldı. tekrarlanabilir                                                           
Dilimli Dilimli Dilimli 0 3 
Aralıklı Dilim aralığına 1 ekler                                                              
Kaydırma Aynı hedef üzerindeki her ardışık Dilim, öncekinden 3 daha fazla hasar verir               
                                                    durumlar                                                     

Silme        Tüm durumları Hedeften kaldırır. 2. Menzil 20 20 
 Düello          Biriniz ölene dek sizi ve hedefinizi dondurur. Menzil 1 25 0 
 Nakavt      Sen ve hedef keneler sonraki 1000 hayrete olan 10 10 
 Meteor        önümüzdeki 100 25 10 keneler için tüm düşmanları afalladı 
 Leash         Hedef onların 2 sonraki dönüşler için 4 ila 6 dondu 
 Zehir        5 döner 1 HP için Zehirler düşman 5 0 
 Sessizlik      Hedef 7 5 dönüş için 5 susturulur 
 yavaş          Hedef 10 5 sonraki 3 tur için 40 keneler tarafından yavaşlatılır 
 Şok          Hedef sonraki 300 için hayrete 10 10 keneler

Soğuk 2 Aralıktaki diğer tüm karakterler 10 onay işareti tarafından yavaşlatılır                                
Bağışıklık Size herhangi bir durum uygulanamaz                                                           
                                                    savunma                                                    

Alan   Bloğunu önümüzdeki 5 hasar kaynağına zorla. Değil yığın 15 5 Does 
 Hayalet         bir dönüş için, tüm hasar iyileşir 10 10 
 Heal          HP 10 3 20 için Hedefi Heal 
 Restore       Tüm birimler tam sağlığına 20 ila 40 geri geri yüklenir 
 Shield        sonraki dönüşü kadar dilimlenmiş olamaz 3 0

Bir dilimin size zarar vermemesi için% 25 kaçınma şansı. tekrarlanabilir                                         
Sütun Sadece bir kez bir tur dilimlenmiş                                                            
Diriliş Öldürüldüğünde, dolu bir HP ile yeniden hayata dön (ve statüsüz) 0 40 
Spike Zarar verildiğinde hasarın yarısını geri alırsın                                           
                                                     Vizyon                                                      

Pelerin         Takımı 5 tur için görünmez hale gelir 20 20 
 Gizle          5 tur için görünmezsin 4 7 
 Aşama         1 tur için görünmez ol 0 3 
 Track         Target görünmez olamaz ve% 10 daha fazla hasar alır. 10 tur sürer. 5 5

Karanlığın Düşman görme alanı 1 azaldı. Yığınlar, ancak 1'in altına inemez.                                 
Uzak görüş Görüş mesafesi 2 arttırıldı. Tekrarlanabilir                                                    
Görünmez Düşman vizyonunu kapatmaya başlarsanız görünmezsiniz                               
Gerçek görüş Sırasındaki başlangıçtaki 2 tüm gizli birimleri gösterir.                                     
                                                     Hasar                                                      

Drenaj         Hedefe 5 hasar verir ve 1 menzilde kaldıklarında 5 HP için kendiliğinden iyileşir 10 5 
 Yıldırım     Tüm düşmanlara 15 hasar 20 10 
 K / O           Hedef% 20'nin altındaysa hedefi öldürür HP 20 0 
 Tuzak          Görünmez bir tuzak yerleştirin. Tuzak, basıldığında 15 hasar verir. Yığınlar. 10 2 
 Zap           Hedef 30'a 30 hasar ver

Statik Fırsatlar 1 menzil içindeki tüm düşmanlara her turda 5 hasar verir. tekrarlanabilir                       
                                                      İstatistikleri                                                      

Werewolf      5 turnuvaya tüm istatistikleri göster 10 30

Buff HP havuzunuzu ikiye katlayın. tekrarlanabilir                                                           
Zeki İşlemler% 20 daha kısa bekleme süresine sahiptir. tekrarlanabilir                                             
Odaklanmış Mana regerasyon oranınızı Int / 10 arttırır. tekrarlanabilir                                  
Yenileme Yenilenme oranınızı Kuvvet / 2 ile artırır. tekrarlanabilir                                 
Akıllı İşlemler 2 daha az mana maliyeti. tekrarlanabilir                                                      
Güçlü 10 özellik puanı kazanırsın. tekrarlanabilir                                                  
Zayıf 15 özellik puanı kaybedersiniz. 2 yetenek slotu kazanırsın (bu onlardan birini alır)                  
                                                      Diğer                                                      

Ayı          Can her Stat 8 10 5 olan bir ayı çağırmak 
 Klon         Klon kendin. İki yetenek slotu alır. 100 100 
 Çalma         Bu eylemi, kullanılan son eylem düşmanı Hedef ile değiştir. 10 dönüş sürer 5 0 
 Duvar          Hedeflenen boş karede geçilmez bir duvar oluşturun, aralık 6 10 10 

Durumları:

• Stun, karakterinizin yalnızca Gülüş eylemini gerçekleştirmesine izin verir ve X onaylarını tutar .
• Dondurma, karakterinizin hareket etmesini önler ve X dönüşleri sürer.
• Sessizlik, karakterinizin Gülümseme, Adım veya Dilim dışında bir şey yapmasını engeller ve X dönüşleri sürer.
• Z, karakterinizi Y dönüşlerinde X hasarı için zarar verir. Başka bir zehir uygularsanız, hasar birlikte eklenir ve süre yenilenir.
• Yavaş, X dönüşlerinizi arasında keneler sayısına X ekler. Yaklaşan dönüşünüzü etkilemez , sadece sonra döner.
• Görünmez hale getirir, böylece rakibiniz tarafından görülmez veya hasar göremezsiniz. Step veya Smile dışında bir işlem yaparsanız kaldırılır. Rakibinin onlara seni görme yeteneğine sahip olması durumunda, görünmezlik ortadan kalkar.

Tüm durumlar (Zehir hariç) birbirinden bağımsız hareket eder.

Yan Notlar:

• Birincil özellik için bir bağ varsa, STR> AGI> INT olarak çözümlenir.
• 10x10'luk bir ızgarada oynuyorsun. Takımlar karşı taraflara yerleştirilecektir.
• Yüzdeler Zeki hariç, çoklu olarak yığınlanır.

Gönderim kuralları

2 işlevi uygulamanız gerekir:

// Create *exactly* 3 Character templates.  You must return the same templates every time
public List<CharacterTemplate> createCharacters();

// Choose an action for a character.  If the action requires a target or location, it must be set.
public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character);

Ayrıca üç değişkene de erişebileceksiniz (üye değişkenler):

Set<ReadonlyCharacter> team;
Set<EnemyCharacter> enemies;
Map<Point2D, EnemyCharacter> visibleEnemies;

Bu kadar. Aşağıda tam bir API'yi alfabetik sıraya göre bulabilirsiniz:

class Ability and ReadonlyAbility
    int getNumSlots() returns the number of slots it takes up
    boolean repeatable() returns true if the ability can be repeated
    String name()
class Action and ReadonlyAction
    Set<Point2D> availableLocations()
    Set<ReadonlyCharacter> availableTargets()
    boolean basicAction() returns true if the action is Smile, Step, or Slice
    boolean breaksInvisibiliby()      
    int getCooldown() returns the cooldown cost (not the cooldown remaining)
    int getManaCost()
    String getName()
    int getRemainingCooldown()
    boolean isAvailable() returns true if the action can be performed
    boolean movementAction() returns true if the action is prevented when Frozen
    boolean needsLocation()
    boolean needsTarget()
    void setTarget(ReadonlyCharacter target)
    void setLocation(Point2D location)
class CharacterTemplate
    void addAbility(Ability)
    boolean canAddAbility(Ability)
    List<Ability> currentAbilities()
    Map<Stat, Integer> currentAttributes()
    int getRemainingPoints() returns the total number of ability points you have left to assign
    int getRemainingSlots() returns the total number of slots you have to assign
    int getStat(Stat stat)
    boolean isValid() returns true if your character template is complete and valid
class Point2D
    getX()
    getY()
class Range
    boolean isCardinal() returns true if the range only extends in the 4 cardinal directions
    int getRange() returns the distance of the range
class ReadonlyCharacter and EnemyCharacter
    Class characterClass()
    int cleverness()
    List<ReadonlyAbility> getAbilities()
    Point2D getLocation()   Not on EnemyCharacter
    double getHealth()
    double getMana()
    int getMaxHealth()
    int getMaxMana()
    Range getSightRange()
    Range getSliceRange()
    int getStat(Stat stat)
    Range getStepRange()
    ReadonlyAction getLastAction()
    boolean isFrozen()
    boolean isStunned()
    boolean isPoisoned()
    int getPoisonAmount()
    boolean isSilenced()
    boolean isInvisible()
    boolean isDead()
    Stat primaryStat()
    int smartness()
enum Stat
    INT, STR, AGI

Yukarıdaki, gönderiminiz için muhtemelen ihtiyaç duyabileceğiniz tüm fonksiyonlardır. Yansıma izin verilmez. Herhangi bir nedenle bir gönderim geçersizse lütfen onu kaldırın veya başlığa "Geçersiz" ekleyin. Gönderdiğiniz gerektiğini değil bir paket beyanı bulunmaktadır. Gönderiniz ilk çok satırlı kod bloğunda yer almalı ve ilk satırın dosya adı olmalıdır.

Proje nasıl çalıştırılır:

Birkaç yol var:

1. JAR dosyasını indirin ve çalıştırın java -jar Fellowship.jar. Diğer gönderileri indirmek istiyorsanız, iletin -q 99744. JRE'ye değil JDK'ya işaret java etmelidir .
2. Klon git repo ve koşmak gradle run. Kepçe yüklü olması gerekir ve bağımsız değişkenleri geçmek istiyorsanız,-PappArgs="['arg1', 'args2']"
3. Klon git repo ve kendiniz derlemek. Aşağıdaki kitaplıkları gerekir: org.eclipse.collections:eclipse-collections-api:8.0.0, org.eclipse.collections:eclipse-collections:8.0.0, com.beust:jcommander:1.48, com.google.code.gson:gson:2.7,org.jsoup:jsoup:1.9.2

Klonlarsanız, --recursivebayrak kullanmanız gerekir ve güncellemeleri yaptığınızda,--recurse-submodules yukarıdakilerden herhangi birini eklemek için, sınıfınızın submissions/javaklasöre girmesi gerekir . Gradle kullanıyorsanız veya kendiniz derliyorsanız, sınıfı projenin içine koyabilirsiniz. Ana işlevdeki bazı satırların satırlarını açmanız ve sınıfınıza işaret etmek için bunları güncellemeniz gerekir.

scoreboard:

+------+-------------------+-------+
| Rank | Name              | Score |
+------+-------------------+-------+
|    1 | TheWalkingDead    | 738.0 |
|    2 | RogueSquad        | 686.0 |
|    3 | Spiky             | 641.0 |
|    4 | Invulnerables     | 609.0 |
|    5 | Noob              | 581.0 |
|    6 | Railbender        | 561.0 |
|    7 | Vampire           | 524.0 |
|    8 | LongSword         | 508.0 |
|    9 | SniperSquad       | 456.0 |
|   10 | BearCavalry       | 430.0 |
|   11 | StaticCloud       | 429.0 |
|   12 | PlayerWerewolf    | 388.0 |
|   13 | LongSwordv2       | 347.0 |
|   14 | Derailer          | 304.0 |
|   15 | Sorcerer          | 266.0 |
|   16 | CowardlySniperMk2 | 262.0 |
|   17 | TemplatePlayer    |  59.0 |
+------+-------------------+-------+

Herhangi bir sorunuz varsa veya yardıma ihtiyacınız varsa, aşağıya yorum yapın veya sohbet odasına katılın ! İyi şanslar ve iyi eğlenceler

StaticCloud

Yaklaşan herkese statik hasar veren, bilinçli ve büyüyen bir bulut. Bu oluşmaktadır:

• 1/3 Görünmez kısım
  • STR: 5; AGI: 5; INT: 25
  • Klon , Görünmez , Statik
• 2/3 Görünür kısım
  • STR: 5; AGI: 5; INT: 25
  • Klon , Statik , Statik

Burada bulunmayan en az bir karakter daha eklediğiniz sürece, buradan takımınızdaki tek karakterleri yeniden kullanabilirsiniz.

StaticCloud.java
import java.util.Arrays;
import java.util.List;

import org.eclipse.collections.api.set.ImmutableSet;
import org.eclipse.collections.impl.factory.Sets;

import com.nmerrill.kothcomm.game.maps.Point2D;

import fellowship.abilities.ActionAbility;
import fellowship.abilities.damage.Static;
import fellowship.abilities.vision.Invisible;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.other.Clone;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;

public class StaticCloud extends SleafarPlayer {
    private CharacterTemplate invisibleTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new Invisible(), new Static());
    }

    private CharacterTemplate visibleTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new Static(), new Static());
    }

    @Override
    public List<CharacterTemplate> createCharacters() {
        return Arrays.asList(visibleTemplate(), invisibleTemplate(), visibleTemplate());
    }

    private class InvisibleCloud extends Character {
        protected InvisibleCloud(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            if (clone != null && (isVisible() || !isInEnemySightRange())) {
                int invisibleCount = countCharacters(InvisibleCloud.class);
                if (invisibleCount > 8 && setClosestSafeLocation(clone, getStaticLocations())) {
                    return clone;
                } else if (setCloneLocation(clone, invisibleCount < 3 ? 3 : 1)) {
                    return clone;
                }
            }
            if (step != null && isVisible() && isInEnemySliceRange() &&
                    setClosestSafeLocation(step, getStaticLocations())) {
                return step;
            }
            if (slice != null && isVisible() && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (step != null) {
                ImmutableSet<Point2D> avoidLocations = !isVisible() || isInEnemySliceRange() ?
                        Sets.immutable.empty() : getEnemySliceLocations();
                if ((isVisible() || clone != null) && !getEnemyHiddenLocations().isEmpty() &&
                        setClosestLocation(step, avoidLocations, getEnemyHiddenLocations())) {
                    return step;
                }
                if (!getStaticLocations().contains(getLocation()) &&
                        setClosestLocation(step, avoidLocations, getStaticLocations())) {
                    return step;
                }
            }
            return smile;
        }
    }

    private class VisibleCloud extends Character {
        protected VisibleCloud(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            if (clone != null) {
                int visibleCount = countCharacters(VisibleCloud.class);
                if (visibleCount > 5 && setClosestSafeLocation(clone, getStaticLocations())) {
                    return clone;
                } else if (setCloneLocation(clone, visibleCount < 3 ? 2 : 1)) {
                    return clone;
                }
            }
            if (step != null && isInEnemySliceRange() && setClosestSafeLocation(step, getStaticLocations())) {
                return step;
            }
            if (slice != null && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (step != null && !getStaticLocations().contains(getLocation())) {
                if (isInEnemySliceRange() ? setClosestLocation(step, getStaticLocations()) :
                        setClosestSafeLocation(step, getStaticLocations())) {
                    return step;
                }
            }
            return smile;
        }
    }

    @Override
    protected Character createCharacter(ReadonlyCharacter delegate) {
        if (hasAbility(delegate, Invisible.class)) {
            return new InvisibleCloud(delegate);
        } else {
            return new VisibleCloud(delegate);
        }
    }
}

Şablon Oynatıcı

Kullanımları Dönüşümlü , Esnek , Zap ve KO . İsterseniz bu yetenek setini kullanma izniniz vardır.

Kendi botunuzu oluşturmak için bu botu şablon olarak kullanmaktan çekinmeyin.

İlk satırdaki dosya adını değiştirmenin ve kendi yetenek setinizi seçmeniz gerektiğini unutmayın.

TemplatePlayer.java
import com.nmerrill.kothcomm.game.maps.Point2D;
import fellowship.abilities.ActionAbility;
import fellowship.abilities.attacking.Flexible;
import fellowship.abilities.attacking.Ranged;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.damage.KO;
import fellowship.actions.damage.Zap;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;
import fellowship.Player;
import org.eclipse.collections.api.set.MutableSet;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class TemplatePlayer extends Player{
    private final double CRITICAL_HEALTH = 20;
    @Override
    public List<CharacterTemplate> createCharacters() {
        List<CharacterTemplate> templates = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            templates.add(new CharacterTemplate(10, 5, 5,
                    new Ranged(),
                    new Flexible(),
                    new ActionAbility(KO::new),
                    new ActionAbility(Zap::new)));
        }
        return templates;
    }

    @Override
    public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {
        int minPriority = Integer.MAX_VALUE;
        ReadonlyAction chosen = null;
        for (ReadonlyAction action: actions){
            int priority = getPriorityFor(action, character);
            if (priority < minPriority){
                chosen = action;
                minPriority = priority;
            }
        }
        if (chosen == null){
            throw new RuntimeException("No valid actions");
        }
        if (chosen.needsLocation()){
            chosen.setLocation(chooseLocationFor(chosen, character));
        } else if (chosen.needsTarget()){
            chosen.setTarget(chooseTargetFor(chosen));
        }
        return chosen;
    }

    private Point2D chooseLocationFor(ReadonlyAction action, ReadonlyCharacter character){
        if (action.movementAction()){
            if (character.getHealth() < CRITICAL_HEALTH){
                return fromEnemy(action.availableLocations());
            } else {
                return toEnemy(action.availableLocations());
            }
        }
        return toTeam(action.availableLocations());
    }

    private Point2D toEnemy(MutableSet<Point2D> availableLocations){
        if (visibleEnemies.isEmpty()){
            return availableLocations.iterator().next();
        }
        return availableLocations.minBy(p1 ->
                p1.cartesianDistance(visibleEnemies.keysView().minBy(p1::cartesianDistance))
        );
    }

    private Point2D fromEnemy(MutableSet<Point2D> availableLocations){
        if (visibleEnemies.isEmpty()){
            return availableLocations.iterator().next();
        }
        return availableLocations.maxBy(p1 ->
                p1.cartesianDistance(visibleEnemies.keysView().minBy(p1::cartesianDistance))
        );
    }

    private Point2D toTeam(MutableSet<Point2D> availableLocations){
        if (team.isEmpty()){
            return availableLocations.iterator().next();
        }
        return availableLocations.minBy(p1 ->
                p1.cartesianDistance(team.collect(ReadonlyCharacter::getLocation).minBy(p1::cartesianDistance))
        );
    }

    private ReadonlyCharacter chooseTargetFor(ReadonlyAction action){
        return action.availableTargets().minBy(ReadonlyCharacter::getHealth);
    }

    private int getPriorityFor(ReadonlyAction action, ReadonlyCharacter character){
        if (character.isInvisible() && action.breaksInvisibility()){
            return 1000;
        }
        if (action.getName().equals("Smile")){
            return 999;
        }
        if (action.movementAction()){
            if (character.getHealth() < 20){
                return 0;
            }
            return 998;
        }
        if (action.needsTarget()) {
            return ((int) action.availableTargets().minBy(ReadonlyCharacter::getHealth).getHealth());
        }
        return 997;
    }
}

CowardlySniperMk2

Zap , FarSight * 2 ve Hide tuşlarını kullanır .

Bu bot bir korkak. En büyük önceliği hedeflenmemektir. Bu amaçla, düşmanların nerede olduğunu görmek için üstün görüşünü kullanır. Bu bilgiyi, düşmanın görülmesi ile takip ederken / takip ederken görülmemek için kullanır. Görülürse veya bir sonraki sırada görülebilirse, bot bir süreliğine görünmez hale gelmeyi 'gizleyecektir'.

İzleme modunda ve yeterli mana ve bekleme süresi sıfırlaması var, o zaman en zayıf görünen düşmanı 'Zap' edecek.

Bir kez mana% 10'a düştüğünde, mana onarılıncaya kadar düşmanlardan uzak duracaksınız. Bu şekilde, izlenen düşmana mümkün olduğu kadar çabuk zap yapabilir. Umarım düşmanın sahip olduğu herhangi bir HP rejimini yok sayar.

'Zap' sınırsız olduğu için, ekip üyelerinin zaplanırken aynı botu hedefleyeceğini unutmayın.

Cevap olarak ekleyebileceğim bu temel fikrin başka çeşitlerini de var: hepsinin mevcut rakiplere bağlı olarak sömürülen / maruz kalan farklı yararları / zararları var.

CowardlySniperMk2.java

import com.nmerrill.kothcomm.game.maps.Point2D;
import fellowship.abilities.ActionAbility;
import fellowship.abilities.vision.FarSight;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.damage.Zap;
import fellowship.actions.vision.Hide;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import fellowship.*;

public class CowardlySniperMk2 extends Player{

    private final static boolean DEBUG=false; 
    private static Point2D lastAttackedEnemyLocation = null;
    private static HashMap<ReadonlyCharacter, Boolean> rechargingManaMap = new HashMap<>();
    private final double STANDARD_VISION_MOVEMENT_BUFFER = 3;
    private final double MIN_VISION_DISTANCE = 2;

    @Override
    public List<CharacterTemplate> createCharacters() {
        List<CharacterTemplate> templates = new ArrayList<>();
        for (int i = 0; i < 3; i++) {
            templates.add(new CharacterTemplate(8, 8, 4,
                    new ActionAbility(Zap::new),
                    new FarSight(),
                    new FarSight(),
                    new ActionAbility(Hide::new)));
        }
        return templates;
    }

    @Override
    public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {

        // get last flag for recharging mana
        Boolean rechargingMana = rechargingManaMap.get(character);
        if (rechargingMana == null || rechargingMana)
        {
            rechargingMana = !(character.getMana()>0.90*character.getMaxMana());
        }
        else
        {
            rechargingMana = character.getMana()<0.10*character.getMaxMana();
        }

        rechargingManaMap.put(character,rechargingMana);

        HashMap<Integer, ReadonlyAction> validActions = new HashMap<>();
        HashMap<Integer, String> actionString = new HashMap<>();

        // see if we have arrived at the last attack location of the enemy
        if (character.getLocation().equals(lastAttackedEnemyLocation))
        {
            lastAttackedEnemyLocation = null;
        }

        double closestEnemyVisionDistance = Double.MAX_VALUE;
        for ( Point2D enemyLocation : visibleEnemies.keySet())
        {
            final int enemyVisibiltyRange = visibleEnemies.get(enemyLocation).getSightRange().getRange();
            double visionDistanceDiff = character.getLocation().diagonalDistance(enemyLocation)-enemyVisibiltyRange;
            if (visionDistanceDiff< closestEnemyVisionDistance)
            {
                closestEnemyVisionDistance = visionDistanceDiff;
            }
        }

        for (ReadonlyAction action: actions){

            int priority=-1;
            String message = "";
            switch (action.getName())
            {
                case "Hide":
                    // are we, or will we be within sight range of an enemy
                    if (closestEnemyVisionDistance < STANDARD_VISION_MOVEMENT_BUFFER )
                    {
                        if (!character.isInvisible())
                        {
                            message = ""+closestEnemyVisionDistance;
                            priority = 1000;
                        }
                    }
                    break;

                case "Step":

                    Point2D chosenLocation = null;

                    // are we within sight range of an enemy or are we recharging mana?
                    if (closestEnemyVisionDistance < MIN_VISION_DISTANCE || rechargingMana)
                    {
                        message = "Fleeing (Seen) "+ closestEnemyVisionDistance;
                        priority = 800;

                        if (character.isInvisible())
                        {
                            message = "Fleeing (UnSeen) "+ closestEnemyVisionDistance;
                            priority = 500;
                        }

                        // simple enemy avoidance... chose location that is farthest away from closest enemy
                        double furthestDistance = 0;

                        for ( Point2D enemyLocation : visibleEnemies.keySet())
                        {
                            for (Point2D location : action.availableLocations())
                            {
                                if (location.diagonalDistance(enemyLocation) > furthestDistance)
                                {
                                    furthestDistance = location.diagonalDistance(enemyLocation);
                                    chosenLocation = location;
                                }
                            }
                        }

                        if (chosenLocation == null)
                        {
                            // no moves are better than staying in current location
                            priority = -1;
                            break;
                        }
                    }
                    // are we "tracking" an enemy?
                    else if (lastAttackedEnemyLocation !=null)
                    {
                        priority = 20;
                        message = "Tracking "+ closestEnemyVisionDistance;

                        // head toward last attacked enemy location
                        double distance = Integer.MAX_VALUE;
                        for (Point2D location : action.availableLocations())
                        {
                            if (location.diagonalDistance(lastAttackedEnemyLocation) < distance)
                            {
                                distance = location.diagonalDistance(lastAttackedEnemyLocation);
                                chosenLocation = location;
                            }
                        }
                    }
                    // are we outside the sight range of all enemies?
                    else if (closestEnemyVisionDistance > STANDARD_VISION_MOVEMENT_BUFFER)
                    {
                        // scout for an enemy

                        priority = 10;
                        message = "Scouting "+ closestEnemyVisionDistance;

                        // dumb random location selection... not optimal but is sufficent.
                        int index = getRandom().nextInt(action.availableLocations().size());
                        for (Point2D location : action.availableLocations())
                        {
                            chosenLocation= location;
                            if (--index == 0)
                            {
                                break;
                            }
                        }
                    }
                    else
                    {
                        // we are in the sweet zone... just out of enemy sight range but within our sight range
                        break;
                    }

                    action.setLocation(chosenLocation);
                    break;

                case "Zap":
                    message = ""+closestEnemyVisionDistance;
                    ReadonlyCharacter chosenTarget = null;
                    double chosenTargetHealth = Double.MAX_VALUE;

                    // target the weakest enemy
                    for (ReadonlyCharacter target : action.availableTargets())
                    {
                        if (target.getHealth() < chosenTargetHealth)
                        {
                            chosenTargetHealth = target.getHealth();
                            chosenTarget = target;
                        }
                    }

                    if (chosenTarget != null)
                    {
                        priority = 100;
                        action.setTarget(chosenTarget);
                        lastAttackedEnemyLocation = chosenTarget.getLocation();
                    }
                    else
                    {
                        // nothing to target
                    }

                    break;

                case "Smile":
                    priority = 0;
                    break;
            }

            // add the action to the collection of valid actions to perform
            if (priority >-1)
            {
                validActions.put(priority, action);
                actionString.put(priority, message);
            }

        }


        int highestPriority = -1;
        ReadonlyAction chosen = null;

        // choose the highest priority action
        for (Integer priority : validActions.keySet())
        {
            if (priority > highestPriority)
            {
                highestPriority = priority;
                chosen = validActions.get(priority);
            }
        }
        String message = actionString.get(highestPriority);

        if (chosen == null){
            throw new RuntimeException("No valid actions");
        }

        if (DEBUG) System.out.println(this+"("+System.identityHashCode(character)+"): "+chosen.getName()+ (rechargingMana?" Mana_charge":" Mana_usable")+" H: "+character.getHealth()+" M: "+character.getMana() +(character.isInvisible()?" InVis":" Vis") +" x: "+character.getLocation().getX()+" y: "+character.getLocation().getY()+" "+message);
        return chosen;
    }
}

The Walking Dead

Zombiler, herkes onları tanıyor. Birisi görünene kadar hiçbir şey yapmadan bir grupta kalıyorlar. Öldürmeleri zor ve kaç kişiyi öldürdüğünüz önemli değil. Ve genellikle arkanızda hiçbir yerde ortaya çıkmazlar.

• 1 x Zombie # 1 (en güçlü ve bu nedenle alfa zombi)
  • STR: 25; AGI: 5; INT: 15
  • Klon , diriltmek , güçlü
• 2 x Zombie # 2 (kapanış kredilerinde kimse Zombie # 3 olmak istemedi, bu yüzden ikisi de aynı sayıya ulaştı)
  • STR: 15; AGI: 5; INT: 15
  • Klon , Resurrect , emdirin

Burada bulunmayan en az bir karakter daha eklediğiniz sürece, buradan takımınızdaki tek karakterleri yeniden kullanabilirsiniz.

TheWalkingDead.java
import java.util.Arrays;
import java.util.List;

import fellowship.abilities.ActionAbility;
import fellowship.abilities.attacking.Absorb;
import fellowship.abilities.defensive.Resurrect;
import fellowship.abilities.stats.Strong;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.other.Clone;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;

public class TheWalkingDead extends SleafarPlayer {
    private CharacterTemplate zombie1Template() {
        return new CharacterTemplate(20, 0, 10, new ActionAbility(Clone::new), new Resurrect(), new Strong());
    }

    private CharacterTemplate zombie2Template() {
        return new CharacterTemplate(10, 0, 10, new ActionAbility(Clone::new), new Resurrect(), new Absorb());
    }

    @Override
    public List<CharacterTemplate> createCharacters() {
        return Arrays.asList(zombie1Template(), zombie2Template(), zombie2Template());
    }

    private class Zombie extends Character {
        private int resurrectCountdown = 0;
        private double oldHealth;

        protected Zombie(ReadonlyCharacter delegate) {
            super(delegate);
            this.oldHealth = getHealth();
        }

        @Override
        protected ReadonlyAction choose() {
            if (getHealth() > oldHealth + getHealthRegen() + 0.1) {
                resurrectCountdown = 40;
            }
            if (resurrectCountdown > 0) {
                --resurrectCountdown;
            }
            oldHealth = getHealth();

            ReadonlyAction clone = getAction(Clone.class);
            if (resurrectCountdown > 0) {
                if (step != null && isInEnemySliceRange() && setAvoidEnemiesLocation(step)) {
                    return step;
                }
                if (clone != null && !getSliceLocations().isEmpty() && setClosestLocation(clone, getSliceLocations())) {
                    return clone;
                }
                if (clone != null && setCloneLocation(clone, 1)) {
                    return clone;
                }
                if (slice != null && setSliceTarget(slice, 0.01)) {
                    return slice;
                }
                if (step != null && setAvoidEnemiesLocation(step)) {
                    return step;
                }
            } else {
                if (clone != null && !getSliceLocations().isEmpty() && setClosestLocation(clone, getSliceLocations())) {
                    return clone;
                }
                if (clone != null && setCloneLocation(clone, 1)) {
                    return clone;
                }
                if (slice != null && setSliceTarget(slice, 0.01)) {
                    return slice;
                }
                if (step != null && !getSliceLocations().isEmpty() && setClosestLocation(step, getSliceLocations())) {
                    return step;
                }
            }
            return smile;
        }
    }

    @Override
    protected Character createCharacter(ReadonlyCharacter delegate) {
        return new Zombie(delegate);
    }
}

Zararsızlar

Neredeyse her şeyden kurtulabilen sert bir savaşçı takımı. Bu, maalesef çoğu zaman kazanamadığım çok fazla zaman aşımına neden oluyor. Ancak, gördüğüm hiçbir eşleşme kazanılamaz ve takım kaybettiğinde, çoğunlukla karakterlerin hayatta kalmasıyla sık sık karşılaşıyor.

Bu takımın en zor maçları Bear Cavalry'ye karşıdır (kelimenin tam anlamıyla bu takımı silemezler, ancak normalde sırf sayıları nedeniyle zıplama kazanırlar); Rogue Squad (takım zehirlenmesi için biraz zayıf); ve Vampir (neden henüz tam olarak emin değilim).

Simülasyonlarda, takım neredeyse her zaman birinci veya ikinci gelir. Puanı oldukça kararlı; Kazanan normal olarak Rogue Squad'in diğer rakiplere karşı ne kadar iyi çalıştığına bağlıdır (yerleşimi, Zararsızlarınkinden çok daha rastgeledir).

Zararlı Küredeki Büyücü

• STR : 5; AGI : 5; INT : 25

Mage, birleşimini kullanarak kendini korur Sütun ve Güç Alanı birleşimini ; olan Odaklı ve yüksek zeka sahip olan, her bir zaman bekleme süresi ile döküm kuvvet alanının yeterli mana oluşturur. Rakiplerinin artırılmış bir Çevikliğe sahip olmadığını varsayarsak, böylece beş turda en fazla beş Dilimle vuruş yapabilir ve bu süre zarfında beş hasar kaynağı engellenir. Başka bir deyişle, Büyücü kesinlikle yenmek için büyü gerektirir; Dilimleme, ne kadar iyi olduğunuz önemli değildir.

Mage acil durumlarda 25 için Dilimleme ile saldırabilir, ancak çoğunlukla yüksek oranda bir MP rejenerasyonu ile çok spam olan Poison'u tekrar tekrar vurur. Poison'un sınırsız bir yelpazesi olduğu için, sadece takımın vizyonuyla sınırlıdır, Mage, bu takımın çok ağır HP veya yenileyici düşmanları yenmesidir; ekibin geri kalanı onlar hakkında vizyon sağlarken, Mage ikinci dereceden hasar verir. Zehir kaçınılmaz olarak sonunda HP rejenerasyonunu geride bırakıyor ve sonunda Spikes gibi statik hasar konusunda endişelenmeme gerek yok.

Dev Clifftop Falconer

• STR : 35; AGI : 5;INT : 5

Falconer'ın asıl işi, ekibin geri kalanına hedeflerin vizyonunu kazandırmak, saldırıya uğramak ve haritayı bir şahin gözüyle izlemektir. Uzak Görüş , saklanmaya veya kaçmaya çalışan düşmanların normalde haritanın bir köşesinde bulunan görme menzili tarafından yakalanabileceği konusunda yeterli görüş sağlar; Falconer'a savaşı vermek çok kolay değil. Doğru Görme , bu ekibin görünmez düşmanlara karşı ana başvurusu, aksi takdirde zararı imkansız olacak. Büyük ve dolayısıyla Güçlü olmak , Falconer'ı hasara karşı çok dirençli ve gerektiğinde ağır Dilimleme kabiliyetine getirir. Sonunda, Falconer, düşmanlarının arasından Dokuma emri vererek ve (35) büyük alan hasarı vererek, aşağıdaki düşman kalabalığındaki şahinlerini serbest bırakabilir .

Falconer'ın kaçınılmaz düşmanları avlamaya ve düşmanların vizyonunu sürdürmeye devam etmesinin yanı sıra, Mage'nin onları zehirlemeye devam edebilmesi için, zaman zaman 35 için Dokuma yeteneği, düşman sürü ekipleriyle baş etmenin anahtarıdır; birçok düşmana bu yolla vurmak ve onları takımın geri kalanını bitirmek için yeterince düşük bırakmak (ideal olarak başka bir Dokuma ile) mümkün. Balık avı bu kurallar altında oldukça güçlenmiş bir stratejidir ve Dokuma sahip olduğu birkaç gerçek sayaçtan biridir. O zaman bile, kendi başına yeterince iyi değil.

Trollbone Skullrender

• STR : 25; AGI : 5; INT : 5

Trollbone'un görevi, düşman ordularını bastırmak ve diğer birimler işlerini yapmaktır. Mage gibi, Trollbone da Knockout'ta sonsuz menzilli bir büyüye sahip . Bu, Mage'nin Zehiriyle çok iyi birleşiyor; Düşmanı birer birer yüzleşmek mümkün olursa (ve birçok takıma karşı), Falconer vizyon kazanacak, Trollbone onları sersemletecek, sonra Mage onlara zehir yığacak ve ölecekler hiçbir şey yapmadan (Knockout, hedefe 1000 tik atıyor ve Trollbone's bunun için bekleme süresini ondan biraz daha hızlı hale getiriyor). Ayrıca Trollbone'u tek güçlü düşmanlara karşı korumakta çok iyidir; bilinçli değilse ona bir şey yapamazlar. Tabii ki, kafataslarını düşmanla parçalamak, ikisini de sarsmaktan sorumlu.sersemletmek ve zehirlemek (ve kimsenin umursamadığı diğer durumlardan bir demet). Yine de sihirli bir şekilde eğimli olmayan büyü odaklı bir karakter olan Trollbone, sihri istihbarat yoluyla değil, düşmanlarının kanını içerek, her vuruşta Mana Steal yaparak yeniler ; Bu, oldukça iyi bir MP yenileme oranı sağlar (ve sersemleten düşmanlar, milletvekilliğini çalmayı kolay hedefler haline getirir). Sonunda, Trollbone bazen bir öfkeyle devam ediyor ve WeaveDüşman rütbesi ile kafalarını kırarak ve kanlarını içerken. Yeterince büyük bir düşman sürüsüne karşı, bu aslında manayı geri kazanıyor ve Falconer'in zayıfladığı bir sürüyü bitirebiliyor (25 + 35 60, bu nedenle düşmanlar arasında bir dereceye kadar yenilenmiş olsa bile).

strateji

Birçok ekipten farklı olarak, sadece ekip oluşturmaya değil, AI'ya da çok odaklanıyorum. Temel kurallardan biri, başka bir şey yapmakla meşgul olmadıklarında, ekibin her zaman gruplaşmaya çalışacak olmalarıdır; Yutulurlarsa, bir köşede saklanmaya çalışırlar. Öte yandan, eğer düşman kaçmaya ya da kaçmaya çalışırsa, haritayı dolaşarak rasgele köşelere ya da merkeze doğru ilerleyerek dolaşıyorlar; bu az çok Falconer'ın sonunda bir hedefi tespit edeceğini garanti eder. Hareket, mümkünse düşmanın ilk darbeyi yapmasına asla izin vermeyecek şekilde tasarlanmıştır; düşmanın kendi dilimindeki dilim aralığına girmesi gerekecek. Büyücü olacak zamanKuvvet Alanı için MP'yi terk ederek MP'nin tükenmesi kaybını önler (bunun başarısız olması için tek yol Absorb'dur, hasar olmasa bile Güç Alanından geçebilir). Bu normalde bir sorun değildir; genellikle Mage, her dönüşü sorunsuz bir şekilde zehirleyebilir. Karşılaşılmadığı takdirde, ekip, bir defada düşmanları kovalamayı, vizyona girdiklerinde onları vurmayı, ardından ölene kadar tekrar tekrar zehirlemeyi tercih ediyor. Etrafındaki diğer düşmanlarla, ekip mümkünse uçurtmaya çalışacak, etrafta dolanacak ve düşmanlarının çoğunu kovalamaya zorlayacak, bunlardan birini çarpıcı ve zehirleyecektir. Asıl sorun sürülerle ilgili, bu yüzden burada çok fazla Dokuma var, ancak o zaman bile stratejiyi yenmek zor görünüyor.

Invulnerables.java
import com.nmerrill.kothcomm.game.maps.Point2D;
import fellowship.abilities.*;
import fellowship.abilities.attacking.*;
import fellowship.abilities.defensive.*;
import fellowship.abilities.vision.*;
import fellowship.abilities.stats.*;
import fellowship.abilities.statuses.*;
import fellowship.actions.*;
import fellowship.actions.attacking.*;
import fellowship.actions.damage.*;
import fellowship.actions.defensive.*;
import fellowship.actions.statuses.*;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;
import fellowship.characters.EnemyCharacter;
import fellowship.*;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class Invulnerables extends Player {
  @Override
  public List<CharacterTemplate> createCharacters() {
    List<CharacterTemplate> templates = new ArrayList<>();

    templates.add(new CharacterTemplate(0, 0, 20,
                                        new ActionAbility(Poison::new),
                                        new ActionAbility(ForceField::new),
                                        new Focused(),
                                        new Pillar()));

    templates.add(new CharacterTemplate(30, 0, 0,
                                        new ActionAbility(Weave::new),
                                        new Strong(),
                                        new FarSight(),
                                        new TrueSight()));

    templates.add(new CharacterTemplate(20, 0, 0,
                                        new ActionAbility(Weave::new),
                                        new ActionAbility(Knockout::new),
                                        new ManaSteal(),
                                        new Immune()));

    return templates;
  }

  private String lastIdentifier(String s) {
    String[] split = s.split("\\W");
    return split[split.length - 1];
  }

  private boolean hasAbility(ReadonlyCharacter character, String abilityName) {
    for (ReadonlyAbility ability : character.getAbilities()) {
      if (lastIdentifier(ability.name()).equals(abilityName))
        return true;
    }
    return false;
  }

  private boolean hasAbility(EnemyCharacter character, String abilityName) {
    for (ReadonlyAbility ability : character.getAbilities()) {
      if (lastIdentifier(ability.name()).equals(abilityName))
        return true;
    }
    return false;
  }

  private int getSquareDanger(ReadonlyCharacter character, Point2D square) {
    /* A square's danger is basically equal to the number of hits we'd
       expect to take when standing there. Each hit is worth 1; a hit of
       25 damage or more is worth 2. */
    int sliceDanger = 0;
    int otherDanger = 0;
    int cx = square.getX();
    int cy = square.getY();
    for (Point2D enemyLocation : visibleEnemies.keysView()) {
      EnemyCharacter enemy = visibleEnemies.get(enemyLocation);
      if (enemy.isStunned())
        continue; /* approaching stunned enemies is a good thing */
      int dx = enemyLocation.getX() - cx;
      int dy = enemyLocation.getY() - cy;
      if (dx < 0)
        dx = -dx;
      if (dy < 0)
        dy = -dy;
      if (dx + dy <= 1) {
        /* We're in Static range. */
        if (hasAbility(enemy, "Static"))
          otherDanger++;
      }
      if (dx + dy <= enemy.getSliceRange().getRange() &&
          (dx * dy == 0 || !enemy.getSliceRange().isCardinal())) {
        int sliceMultiplier = 1;
        if (hasAbility(enemy, "Quick") && !hasAbility(character, "Pillar"))
          sliceMultiplier *= 2;
        if (enemy.getStat(enemy.primaryStat()) >= 25)
          sliceMultiplier *= 2;
        if (hasAbility(character, "Pillar")) {
          if (sliceDanger >= sliceMultiplier)
            continue;
          sliceDanger = 0;
        }
        sliceDanger += sliceMultiplier;
      }
    }
    return sliceDanger + otherDanger;
  }

  private ReadonlyAction[] forceFieldAction = new ReadonlyAction[3];
  private int goalX = 5;
  private int goalY = 5;

  @Override
  public ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {

    /* Which character are we? */
    int characterNumber;
    if (hasAbility(character, "Focused"))
      characterNumber = 0;
    else if (hasAbility(character, "Immune"))
      characterNumber = 1;
    else if (hasAbility(character, "TrueSight"))
      characterNumber = 2;
    else
      throw new RuntimeException("Unrecognised character!");

    /* If we're at the goal square, pick a new one. */
    if (goalX == character.getLocation().getX() &&
        goalY == character.getLocation().getY()) {
      int i = getRandom().nextInt(5);
      goalX = i < 2 ? 1 : i > 2 ? 9 : 5;
      goalY = i == 2 ? 5 : (i % 2) == 1 ? 1 : 9;
    }

    /* If there are a lot of visible enemies, try to group up in a corner in order
       to prevent being surrounded. */
    if (visibleEnemies.size() > 3) {
      int xVotes = 0;
      int yVotes = 0;
      for (ReadonlyCharacter ally : team) {
        xVotes += ally.getLocation().getX() >= 5 ? 1 : -1;
        yVotes += ally.getLocation().getY() >= 5 ? 1 : -1;
      }
      goalX = xVotes > 0 ? 9 : 0;
      goalY = yVotes > 0 ? 9 : 0;
    }

    /* We need to know our Force Field cooldowns even between turns, so store the
       actions in a private field for later use (they aren't visible via the API) */
    for (ReadonlyAction action : actions) {
      if (action.getName().equals("ForceField"))
        forceFieldAction[characterNumber] = action;
    }

    /* If we know Force Field, ensure we always hang on to enough mana to cast it, and
       never allow our mana to dip low enough that it wouldn't regenerate in time. */
    double mpFloor = 0.0;
    if (forceFieldAction[characterNumber] != null) {
      double mpRegen = character.getStat(Stat.INT) / 10.0;
      if (hasAbility(character, "Focused"))
        mpRegen *= 2;
      mpFloor = forceFieldAction[characterNumber].getManaCost();
      mpFloor -= forceFieldAction[characterNumber].getRemainingCooldown() * mpRegen;
    }
    if (mpFloor > character.getMana())
      mpFloor = character.getMana();

    /* We use a priority rule for actions. */
    int bestPriority = -2;
    ReadonlyAction bestAction = null;
    for (ReadonlyAction action : actions) {
      int priority = 0;
      if (lastIdentifier(action.getName()).equals("ForceField"))
        priority = 20; /* top priority */
      else if (character.getMana() - action.getManaCost() < mpFloor) {
        continue; /* never spend mana if it'd block a force field */
      } else if (lastIdentifier(action.getName()).equals("Quick") ||
                 lastIdentifier(action.getName()).equals("Slice")) {
        int damagePotential =
          lastIdentifier(action.getName()).equals("Quick") ? 50 : 25;
        /* We use these abilities with very high priority to /kill/ an enemy
           who's weak enough to die from the damage. If they wouldn't die,
           we're much more wary about attacking; we do it only if we have
           nothing better to do and it's safe. */
        ReadonlyCharacter chosenTarget = null;
        for (ReadonlyCharacter target : action.availableTargets()) {
          if (!isEnemy(target))
            continue;
          if (target.getHealth() <= damagePotential) {
            chosenTarget = target;
            priority = (damagePotential == 25 ? 19 : 18);
            break; /* can't do beter than this */
          }
          if (hasAbility(target, "Spikes") ||
              hasAbility(target, "Reflexive"))
            /*  (target.getLastAction() != null &&
                target.getLastAction().getName().equals("Ghost")) */
            continue; /* veto the target */
          priority = (damagePotential == 25 ? 3 : 4);
          chosenTarget = target;
        }
        if (chosenTarget == null)
          continue;
        action.setTarget(chosenTarget);
      } else if (lastIdentifier(action.getName()).equals("Weave")) {
        priority = visibleEnemies.size() >= 3 ? 14 :
          visibleEnemies.size() >= 1 ? 6 : -1;
      } else if (lastIdentifier(action.getName()).equals("Smile")) {
        /* If there's a stunned or poisoned enemy in view, we favour Smile
           as the idle action, rather than exploring, so that we don't
           move it out of view. Exception: if they're the only enemy;
           in that case, hunt them down. Another exception: if we're
           running into a corner. */
        for (EnemyCharacter enemy : visibleEnemies) {
          if (enemy.isStunned() || enemy.isPoisoned())
            if (visibleEnemies.size() > 1 && visibleEnemies.size() < 4)
              priority = 2;
        }
        /* otherwise we leave it as 0, and Smile only as a last resort */
      } else if (lastIdentifier(action.getName()).equals("Knockout")) {
        /* Use this only on targets who have more than 50 HP. It doesn't
           matter where they are: if we can see them now, knocking them
           out will guarantee we can continue to see them. Of course, if
           they're already knocked out, don't use it (although this case
           should never come up). If there's only one enemy target in
           view, knocking it out has slightly higher priority, because
           we don't need to fear enemy attacks if all the enemies are
           knocked out.

           Mildly favour stunning poisoned enemies; this reduces the
           chance that they'll run out of sight and reset the poison. */
        ReadonlyCharacter chosenTarget = null;
        for (ReadonlyCharacter target : action.availableTargets())
          if ((target.getHealth() > 50 || target.isPoisoned()) &&
              !target.isStunned() && isEnemy(target)) {
            chosenTarget = target;
            if (target.isPoisoned())
              break;
          }
        if (chosenTarget == null)
          continue;
        action.setTarget(chosenTarget);
        priority = visibleEnemies.size() == 1 ? 17 : 15;
      } else if (lastIdentifier(action.getName()).equals("Poison")) {
        /* Use this preferentially on stronger enemies, and preferentially
           on enemies who are more poisoned. We're willing to poison
           almost anyone, although weak enemies who aren't poisoned
           are faster to kill via slicing. The cutoff is at 49, not 50,
           so that in the case of evasive enemies who we can't hit any
           other way, we can wear them one at a time using poison. */
        ReadonlyCharacter chosenTarget = null;
        int chosenTargetPoisonLevel = -1;
        for (ReadonlyCharacter target : action.availableTargets()) {
          int poisonLevel = 0;

          if (!isEnemy(target))
            continue;
          if (target.isPoisoned())
            poisonLevel = target.getPoisonAmount() + 1;
          if (poisonLevel < chosenTargetPoisonLevel)
            continue;
          if (poisonLevel == 0 && target.getHealth() <= 49)
            continue; /* prefer stronger targets */
          if (poisonLevel == 0 && target.getHealth() == 50 &&
              chosenTarget != null)
            continue; /* we poison at 50, but not with other options */
          chosenTarget = target;
          chosenTargetPoisonLevel = poisonLevel;
          priority = 12;
        }
        if (chosenTarget == null)
          continue;
        action.setTarget(chosenTarget);
      } else if (action.movementAction()) {
        /* A move to a significantly safer square is worth 16.
           A move to a mildly safer square is worth 8.
           Otherwise, move to group, either with the enemy,
           the team, or the goal, at priority 1, if we
           safely can; that's our "idle" action. */
        int currentSquareDanger =
          getSquareDanger(character, character.getLocation());
        int bestSquareDanger = currentSquareDanger;
        int bestGroupiness = 0;
        Point2D bestLocation = null;
        priority = 1;
        for (Point2D location :
               action.availableLocations().toList().shuffleThis(getRandom())) {
          int danger = getSquareDanger(character, location);
          if (danger > bestSquareDanger)
            continue;
          else if (danger < bestSquareDanger) {
            priority = (currentSquareDanger - danger > 2)
              ? 16 : 8;
            bestSquareDanger = danger;
            bestLocation = location;
            bestGroupiness = 0; /* reset the tiebreak */
          }

          int cx = character.getLocation().getX();
          int xDelta = location.getX() - cx;
          int cy = character.getLocation().getY();
          int yDelta = location.getY() - cy;
          int groupiness = 0;
          /* Always hunt down a visible enemy when they're the only
             remaining enemy and doing so is safe. Otherwise, still
             favour hunting them down, but in that situation also
             consider factors like grouping and exploration. */
          for (Point2D enemyLocation : visibleEnemies.keysView())
            if (xDelta * (enemyLocation.getX() - cx) > 0 ||
                yDelta * (enemyLocation.getY() - cy) > 0)
              groupiness += (visibleEnemies.size() == 1 ? 99 : 5);
          /* If there are 4 or more visible enemies, then grouping is
             vitally important (so as to not get surrounded).
             Otherwise, it's more minor. */
          for (ReadonlyCharacter ally : team)
            if (xDelta * (ally.getLocation().getX() - cx) > 0 ||
                yDelta * (ally.getLocation().getY() - cy) > 0)
              groupiness += (visibleEnemies.size() > 3 ? 99 : 3);
          /* When exploring, we bias towards random map locations,
             changing location when we reach them. This helps us beat
             enemies that hide in the corners. When there are a lot
             of visible enemies, this changes to a bias to hide in a
             corner. */
          if (xDelta * (goalX - cx) > 0 ||
              yDelta * (goalY - cy) > 0)
            groupiness += (visibleEnemies.size() > 3 ? 99 : 4);
          if (groupiness >= bestGroupiness) {
            bestLocation = location;
            bestGroupiness = groupiness;
            /* leave priority, safety untouched */
          }
        }
        if (bestLocation == null)
          continue;
        action.setLocation(bestLocation);
      } else
        throw new RuntimeException("unknown action" + action.getName());

      if (priority > bestPriority) {
        bestPriority = priority;
        bestAction = action;
      }
    }
    if (bestAction == null)
      throw new RuntimeException("no action?");

    return bestAction;
  }
}

RogueSquad

Bir hileli kadro şunlardan oluşur:

• 1 İzci (haritayı keşfederken gölgede kalır)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Görünmez , Uzak Görüş
• 2 suikastçı (ölümcül zehirli düşmanlara saldırmak)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Zehir , Odaklanmış

Her ikisinin de kullanabileceği en büyük güç, onları desteklemesi için ek kadro üyelerini çağırmaktır.

Burada bulunmayan en az bir karakter daha eklediğiniz sürece, buradan takımınızdaki tek karakterleri yeniden kullanabilirsiniz.

RogueSquad.java
import java.util.Arrays;
import java.util.List;

import fellowship.abilities.ActionAbility;
import fellowship.abilities.stats.Focused;
import fellowship.abilities.vision.FarSight;
import fellowship.abilities.vision.Invisible;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.other.Clone;
import fellowship.actions.statuses.Poison;
import fellowship.characters.CharacterTemplate;
import fellowship.characters.ReadonlyCharacter;

public class RogueSquad extends SleafarPlayer {
    private CharacterTemplate scoutTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new Invisible(), new FarSight());
    }

    private CharacterTemplate assasinTemplate() {
        return new CharacterTemplate(0, 0, 20,
                new ActionAbility(Clone::new), new ActionAbility(Poison::new), new Focused());
    }

    @Override
    public List<CharacterTemplate> createCharacters() {
        return Arrays.asList(assasinTemplate(), scoutTemplate(), assasinTemplate());
    }

    private class Scout extends Character {
        protected Scout(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            if (clone != null && (isVisible() || !isInEnemySightRange()) && setCloneLocation(clone, 3)) {
                return clone;
            }
            if (step != null && isVisible() && isInEnemySliceRange() && setAvoidEnemiesLocation(step)) {
                return step;
            }
            if (slice != null && isVisible() && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (step != null && isVisible() && setAvoidEnemiesLocation(step)) {
                return step;
            }
            if (step != null && !isVisible() && setExploreLocation(step)) {
                return step;
            }
            return smile;
        }
    }

    private class Assasin extends Character {
        protected Assasin(ReadonlyCharacter delegate) {
            super(delegate);
        }

        @Override
        protected ReadonlyAction choose() {
            ReadonlyAction clone = getAction(Clone.class);
            ReadonlyAction poison = getAction(Poison.class);
            if (clone != null && setCloneLocation(clone, 1)) {
                return clone;
            }
            if (step != null && isInEnemySliceRange() && setAvoidEnemiesLocation(step)) {
                return step;
            }
            if (slice != null && setSliceTarget(slice, 0.01)) {
                return slice;
            }
            if (poison != null && setPoisonTarget(poison)) {
                return poison;
            }
            if (step != null && setAvoidEnemiesLocation(step)) {
                return step;
            }
            return smile;
        }
    }

    @Override
    protected Character createCharacter(ReadonlyCharacter delegate) {
        if (hasAbility(delegate, Invisible.class)) {
            return new Scout(delegate);
        } else if (hasAbility(delegate, Poison.class)) {
            return new Assasin(delegate);
        } else {
            throw new IllegalArgumentException();
        }
    }
}

Tüm botlarım için temel sınıf

SleafarPlayer.java
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.collections.api.RichIterable;
import org.eclipse.collections.api.map.ImmutableMap;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.set.ImmutableSet;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.api.tuple.Pair;
import org.eclipse.collections.impl.factory.Maps;
import org.eclipse.collections.impl.factory.Sets;
import org.eclipse.collections.impl.list.primitive.IntInterval;
import org.eclipse.collections.impl.tuple.Tuples;

import com.nmerrill.kothcomm.game.maps.Point2D;

import fellowship.Player;
import fellowship.Range;
import fellowship.abilities.ReadonlyAbility;
import fellowship.abilities.attacking.Critical;
import fellowship.abilities.attacking.Reflexive;
import fellowship.abilities.defensive.Spikes;
import fellowship.abilities.statuses.Immune;
import fellowship.actions.ReadonlyAction;
import fellowship.actions.attacking.Quick;
import fellowship.actions.attacking.Slice;
import fellowship.actions.mobility.Step;
import fellowship.actions.other.Smile;
import fellowship.characters.CharacterInterface;
import fellowship.characters.EnemyCharacter;
import fellowship.characters.ReadonlyCharacter;

public abstract class SleafarPlayer extends Player {
    private static final ImmutableSet<Point2D> MAP_LOCATIONS = IntInterval.fromTo(0, 9)
            .collect(x -> IntInterval.fromTo(0, 9).collect(y -> new Point2D(x, y))).flatCollect(t -> t).toSet()
            .toImmutable();
    protected static final Comparator<CharacterInterface> HEALTH_COMPARATOR = (o1, o2) ->
            Double.compare(o1.getHealth(), o2.getHealth());
    private static final Range BLOCKING_RANGE = new Range(1, true);
    private static final Range STATIC_RANGE = new Range(1);

    protected static boolean hasAbility(CharacterInterface character, Class<?> ability) {
        return character.getAbilities().anySatisfy(a -> a.abilityClass().equals(ability));
    }

    protected static boolean isBear(CharacterInterface character) {
        return character.getAbilities().isEmpty();
    }

    protected static double calcSliceDamage(CharacterInterface character) {
        return character.getStat(character.primaryStat()) * (hasAbility(character, Quick.class) ? 2.0 : 1.0);
    }

    protected static boolean setLocation(ReadonlyAction action, Point2D location) {
        if (location != null) {
            action.setLocation(location);
        }
        return location != null;
    }

    protected static boolean setTarget(ReadonlyAction action, ReadonlyCharacter target) {
        if (target != null) {
            action.setTarget(target);
        }
        return target != null;
    }

    protected abstract class Character {
        protected final ReadonlyCharacter delegate;

        protected Character(ReadonlyCharacter delegate) {
            super();
            this.delegate = delegate;
        }

        protected abstract ReadonlyAction choose();

        protected double getHealth() {
            return delegate.getHealth();
        }

        protected double getHealthRegen() {
            return delegate.getHealthRegen();
        }

        protected double getMana() {
            return delegate.getMana();
        }

        protected double getManaRegen() {
            return delegate.getManaRegen();
        }

        protected Point2D getLocation() {
            return delegate.getLocation();
        }

        protected boolean isVisible() {
            return !delegate.isInvisible();
        }

        protected double getSliceDamage() {
            return delegate.getStat(delegate.primaryStat());
        }

        protected boolean isInEnemySliceRange() {
            return getEnemySliceLocations().contains(delegate.getLocation());
        }

        protected boolean isInEnemySightRange() {
            return getEnemySightLocations().contains(delegate.getLocation());
        }

        protected boolean isInEnemyStepSightRange() {
            return getEnemyStepSightLocations().contains(delegate.getLocation());
        }

        protected double calcSliceRetaliationDamage(CharacterInterface character) {
            double result = 0.0;
            double ownDamage = getSliceDamage();
            for (ReadonlyAbility ability : character.getAbilities()) {
                if (ability.abilityClass().equals(Critical.class)) {
                    ownDamage = ownDamage * 2;
                }
            }
            for (ReadonlyAbility ability : character.getAbilities()) {
                if (ability.abilityClass().equals(Spikes.class)) {
                    result += ownDamage / 2.0;
                } else if (ability.abilityClass().equals(Reflexive.class)) {
                    result += character.getStat(character.primaryStat());
                }
            }
            return result;
        }

        protected double calcSpellRetaliationDamage(CharacterInterface character, double ownDamage) {
            double result = 0.0;
            for (ReadonlyAbility ability : character.getAbilities()) {
                if (ability.abilityClass().equals(Spikes.class)) {
                    result += ownDamage / 2.0;
                }
            }
            return result;
        }

        protected boolean setRandomLocation(ReadonlyAction action) {
            return setLocation(action, chooseRandom(action.availableLocations()));
        }

        protected boolean setRandomLocation(ReadonlyAction action, ImmutableSet<Point2D> avoidLocations) {
            return setLocation(action, chooseRandom(action.availableLocations().difference(avoidLocations)));
        }

        protected boolean setClosestLocation(ReadonlyAction action, ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseClosest(action.availableLocations(), targetLocations));
        }

        protected boolean setClosestLocation(ReadonlyAction action, ImmutableSet<Point2D> avoidLocations,
                ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseClosest(action.availableLocations().difference(avoidLocations),
                    targetLocations));
        }

        protected boolean setClosestHiddenLocation(ReadonlyAction action, ImmutableSet<Point2D> preferredLocations) {
            return setClosestLocation(action, getEnemySightLocations(), preferredLocations);
        }

        protected boolean setClosestSafeLocation(ReadonlyAction action, ImmutableSet<Point2D> preferredLocations) {
            return setClosestLocation(action, getEnemySliceLocations(), preferredLocations);
        }

        protected boolean setFarthestLocation(ReadonlyAction action, ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseFarthest(action.availableLocations(), targetLocations));
        }

        protected boolean setFarthestLocation(ReadonlyAction action, ImmutableSet<Point2D> avoidLocations,
                ImmutableSet<Point2D> targetLocations) {
            return setLocation(action, chooseFarthest(action.availableLocations().difference(avoidLocations),
                    targetLocations));
        }

        public boolean setCloneLocation(ReadonlyAction action, int distance) {
            ImmutableSet<Point2D> cloneLocations = distance < 2 ? team.collect(t -> t.getLocation()).toImmutable() :
                team.flatCollect(t -> t.rangeAround(new Range(distance))).difference(
                team.flatCollect(t -> t.rangeAround(new Range(distance - 1)))).toImmutable();
            if (cloneLocations.isEmpty()) {
                return setRandomLocation(action, getEnemySightLocations()) ||
                        setRandomLocation(action, getEnemySliceLocations()) ||
                        setRandomLocation(action);
            } else {
                return setClosestLocation(action, getEnemySightLocations(), cloneLocations) ||
                        setClosestLocation(action, getEnemySliceLocations(), cloneLocations) ||
                        setClosestLocation(action, cloneLocations);
            }
        }

        protected boolean setAvoidEnemiesLocation(ReadonlyAction action) {
            Point2D location = chooseFarthest(Sets.mutable.ofAll(action.availableLocations())
                    .with(delegate.getLocation()).difference(getEnemySliceLocations()), getEnemyLocations());
            if (location == null || location.equals(delegate.getLocation())) {
                return false;
            } else {
                return setLocation(action, location);
            }
        }

        protected boolean setBlockEnemiesLocation(ReadonlyAction action) {
            return setLocation(action, chooseRandom(action.availableLocations().intersect(getEnemyBlockingLocations())));
        }

        protected boolean setExploreLocation(ReadonlyAction action) {
            return visibleEnemies.size() < enemies.size() && getTeamHiddenLocations().notEmpty() &&
                    setClosestLocation(action, getEnemyStepSightLocations(), getTeamHiddenLocations());
        }

        protected boolean setSliceTarget(ReadonlyAction action, double minHealthReserve) {
            MutableSet<Pair<ReadonlyCharacter, Double>> pairs = action.availableTargets()
                    .collect(t -> Tuples.pair(t, calcSliceRetaliationDamage(t)));
            Pair<ReadonlyCharacter, Double> smallest = chooseSmallest(pairs, (o1, o2) -> {
                int c = Double.compare(o1.getTwo(), o2.getTwo());
                return c == 0 ? Double.compare(o1.getOne().getHealth(), o2.getOne().getHealth()) : c;
            });
            if (smallest == null || smallest.getTwo() > delegate.getHealth() - minHealthReserve) {
                return false;
            } else {
                return setTarget(action, smallest.getOne());
            }
        }

        protected boolean setPoisonTarget(ReadonlyAction action) {
            return setTarget(action, chooseSmallest(action.availableTargets().reject(c -> hasAbility(c, Immune.class)),
                    HEALTH_COMPARATOR));
        }

        protected final ImmutableSet<Point2D> getEnemyLocations() {
            if (enemyLocations == null) {
                enemyLocations = visibleEnemies.keysView().toSet().toImmutable();
            }
            return enemyLocations;
        }

        protected final ImmutableSet<Point2D> getEnemySliceLocations() {
            if (enemySliceLocations == null) {
                enemySliceLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(c.getTwo().getSliceRange(), c.getOne())).toSet()
                        .toImmutable();
            }
            return enemySliceLocations;
        }

        protected final ImmutableSet<Point2D> getEnemySightLocations() {
            if (enemySightLocations == null) {
                enemySightLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(c.getTwo().getSightRange(), c.getOne())).toSet()
                        .toImmutable();
            }
            return enemySightLocations;
        }

        protected final ImmutableSet<Point2D> getEnemyStepSightLocations() {
            if (enemyStepSightLocations == null) {
                enemyStepSightLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> Sets.mutable.ofAll(c.getTwo().rangeAround(c.getTwo().getStepRange(), c.getOne()))
                                .with(c.getOne()).flatCollect(r -> c.getTwo().rangeAround(c.getTwo().getSightRange(), r)))
                        .toSet().toImmutable();
            }
            return enemyStepSightLocations;
        }

        protected final ImmutableSet<Point2D> getEnemyHiddenLocations() {
            if (enemyHiddenLocations == null) {
                enemyHiddenLocations = MAP_LOCATIONS.difference(getEnemySightLocations());
            }
            return enemyHiddenLocations;
        }

        protected final ImmutableSet<Point2D> getEnemyBlockingLocations() {
            if (enemyBlockingLocations == null) {
                enemyBlockingLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(BLOCKING_RANGE, c.getOne())).toSet().toImmutable();
            }
            return enemyBlockingLocations;
        }

        protected final ImmutableSet<Point2D> getTeamHiddenLocations() {
            if (teamHiddenLocations == null) {
                teamHiddenLocations = MAP_LOCATIONS.difference(team.flatCollect(c -> c.rangeAround(c.getSightRange())));
            }
            return teamHiddenLocations;
        }

        protected final ImmutableSet<Point2D> getTeamBlockingLocations() {
            if (teamBlockingLocations == null) {
                teamBlockingLocations = team.flatCollect(c -> c.rangeAround(BLOCKING_RANGE)).toImmutable();
            }
            return teamBlockingLocations;
        }

        protected final ImmutableSet<Point2D> getSliceLocations() {
            if (sliceLocations == null) {
                sliceLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(delegate.getSliceRange(), c.getOne())).toSet().toImmutable();
            }
            return sliceLocations;
        }

        protected final ImmutableSet<Point2D> getStaticLocations() {
            if (staticLocations == null) {
                staticLocations = visibleEnemies.keyValuesView()
                        .flatCollect(c -> c.getTwo().rangeAround(STATIC_RANGE, c.getOne())).toSet().toImmutable();
            }
            return staticLocations;
        }

        protected final ImmutableMap<Point2D, Double> getEnemySliceDamage() {
            if (enemySliceDamage == null) {
                MutableMap<Point2D, Double> tmp = MAP_LOCATIONS.toMap(l -> l, l -> 0.0);
                for (Pair<Point2D, EnemyCharacter> p : visibleEnemies.keyValuesView()) {
                    double damage = calcSliceDamage(p.getTwo());
                    for (Point2D l : p.getTwo().rangeAround(p.getTwo().getSliceRange(), p.getOne())) {
                        tmp.put(l, tmp.get(l) + damage);
                    }
                }
                enemySliceDamage = tmp.toImmutable();
            }
            return enemySliceDamage;
        }
    }

    protected ImmutableMap<ReadonlyCharacter, Character> characters = Maps.immutable.empty();

    private ImmutableMap<Class<?>, ReadonlyAction> actions = null;
    protected ReadonlyAction step = null;
    protected ReadonlyAction slice = null;
    protected ReadonlyAction smile = null;

    private ImmutableSet<Point2D> enemyLocations = null;
    private ImmutableSet<Point2D> enemySliceLocations = null;
    private ImmutableSet<Point2D> enemySightLocations = null;
    private ImmutableSet<Point2D> enemyStepSightLocations = null;
    private ImmutableSet<Point2D> enemyHiddenLocations = null;
    private ImmutableSet<Point2D> enemyBlockingLocations = null;
    private ImmutableSet<Point2D> teamHiddenLocations = null;
    private ImmutableSet<Point2D> teamBlockingLocations = null;
    private ImmutableSet<Point2D> sliceLocations = null;
    private ImmutableSet<Point2D> staticLocations = null;
    private ImmutableMap<Point2D, Double> enemySliceDamage = null;

    protected final <T> T chooseRandom(Collection<T> collection) {
        if (!collection.isEmpty()) {
            int i = getRandom().nextInt(collection.size());
            for (T t : collection) {
                if (i == 0) {
                    return t;
                }
                --i;
            }
        }
        return null;
    }

    protected final <T> T chooseSmallest(Collection<T> collection, Comparator<? super T> comparator) {
        if (!collection.isEmpty()) {
            List<T> list = new ArrayList<>();
            for (T t : collection) {
                if (list.isEmpty()) {
                    list.add(t);
                } else {
                    int c = comparator.compare(t, list.get(0));
                    if (c < 0) {
                        list.clear();
                    }
                    if (c <= 0) {
                        list.add(t);
                    }
                }
            }
            return list.get(getRandom().nextInt(list.size()));
        }
        return null;
    }

    protected final Point2D chooseClosest(Collection<Point2D> available, RichIterable<Point2D> targets) {
        if (targets.isEmpty()) {
            return chooseRandom(available);
        } else {
            Map<Point2D, Integer> map = new HashMap<>();
            for (Point2D a : available) {
                map.put(a, targets.collect(t -> t.cartesianDistance(a)).min());
            }
            return chooseSmallest(available, (o1, o2) -> Integer.compare(map.get(o1), map.get(o2)));
        }
    }

    protected final Point2D chooseFarthest(Collection<Point2D> available, RichIterable<Point2D> targets) {
        if (targets.isEmpty()) {
            return chooseRandom(available);
        } else {
            Map<Point2D, Integer> map = new HashMap<>();
            for (Point2D a : available) {
                map.put(a, targets.collect(t -> t.cartesianDistance(a)).min());
            }
            return chooseSmallest(available, (o1, o2) -> Integer.compare(map.get(o2), map.get(o1)));
        }
    }

    protected int countCharacters(Class<?> clazz) {
        return characters.count(c -> c.getClass().equals(clazz));
    }

    protected ReadonlyAction getAction(Class<?> clazz) {
        return actions.get(clazz);
    }

    protected abstract Character createCharacter(ReadonlyCharacter delegate);

    @Override
    public final ReadonlyAction choose(Set<ReadonlyAction> actions, ReadonlyCharacter character) {
        characters = team.collect(c -> characters.getIfAbsentWith(c, this::createCharacter, c))
                .groupByUniqueKey(c -> c.delegate).toImmutable();

        this.actions = Sets.immutable.ofAll(actions).groupByUniqueKey(ReadonlyAction::actionClass);
        step = getAction(Step.class);
        slice = getAction(Slice.class);
        smile = getAction(Smile.class);

        enemyLocations = null;
        enemySliceLocations = null;
        enemySightLocations = null;
        enemyStepSightLocations = null;
        enemyHiddenLocations = null;
        enemyBlockingLocations = null;
        teamHiddenLocations = null;
        teamBlockingLocations = null;
        sliceLocations = null;
        staticLocations = null;
        enemySliceDamage = null;

        return characters.get(character).choose();
    }
}