Dalam tantangan ini, Anda akan membuat Fellowship dengan tujuan mengalahkan semua fellowship lain dalam pertempuran.

Persekutuan (tim) terdiri dari 3 karakter . Setiap karakter bergerak secara independen dari anggota tim mereka yang lain, tetapi mereka harus bekerja bersama saat melawan musuh Anda. Tim akan saling berhadapan satu sama lain secara bergiliran. Menang bernilai 3 poin, ikatan bernilai 1 poin, dan kerugian bernilai 0 poin.

Karakter memiliki Kemampuan. Pilihan kemampuan apa yang dimiliki karakter Anda adalah salah satu bagian paling penting (dan menyenangkan) di KotH ini . Mereka semua kuat, dan memiliki potensi untuk melenyapkan musuh Anda.

Karakter memiliki Poin Kesehatan (HP), dan ketika HP mereka menyentuh (atau pergi di bawah) 0, mereka mati . Jika semua karakter di tim lawan mati, maka Anda menang!

Karakter memiliki Mana. Sebagian besar tindakan memerlukan Mana untuk melakukan , dan jika Anda tidak memiliki cukup, tindakan itu tidak tersedia untuk Anda.

Karakter mengalami Delay Turn . Ini menentukan jumlah kutu di antara setiap belokan (mulai dari 100). Lebih rendah lebih baik.

Karakter memiliki atribut . Setiap karakter memiliki basis 5 di setiap atribut, dan Anda diberi 20 poin atribut tambahan untuk dibagi. Setelah menetapkan poin atribut, atribut utama Anda ditetapkan sebagai atribut tertinggi Anda.

Atribut yang tersedia adalah:

• Kekuatan: Memberikan 10 Max HP dan 0,5 HP per putaran
• Intelijen: Memberikan 7 Max Mana dan .1 Mana per giliran
• Agility: Mengurangi Delay Turn oleh 1

Gerakan, Visi, Rentang
Rentang adalah sebagai berikut (berpusat di sekitar 0). Beberapa rentang bersifat kardinal , yang berarti mereka hanya bisa naik langsung, kiri, kanan, atau turun.

    444
   43334
  4322234
 432111234
 432101234
 432111234
  4322234
   43334
    444

Karakter memiliki visi awal 2. Visi antara pemain dari persekutuan yang sama dibagi.

Cara bermain

Pemain Konstruksi akan membangun persekutuan mereka. Anda perlu melakukan langkah-langkah berikut :

1. Berikan masing-masing poin atribut karakter . Setiap karakter dimulai dengan 5 di setiap stat, dengan tambahan 20 untuk mendistribusikan antara 3.

2. Berikan masing-masing kemampuan karakter . Setiap karakter dimulai dengan 4 slot kemampuan, dan kemampuan mengambil 1 slot secara default. Beberapa kemampuan dapat diulang , dan dapat diberikan ke karakter beberapa kali. Menggunakan kumpulan kemampuan pengajuan lain tanpa izin pemilik tidak diizinkan.

3. Tulis beberapa kode untuk bot Anda. Kode harus dalam Java, dan akan digunakan untuk memerangi (langkah selanjutnya)

Tindakan

Semua karakter dimulai dengan 3 tindakan standar:

1. Langkah : Pindahkan karakter Anda dalam kisaran kardinal 1
2. Slice : Serang musuh untuk PrimaryAttribute dalam kisaran kardinal 1
3. Senyum : Jangan lakukan apa pun

Pada giliran karakter, maka harus memilih tindakan untuk dilakukan. Tindakan mungkin memiliki biaya Mana, dan mungkin memiliki Cooldown, yang menentukan jumlah belokan yang harus Anda tunggu sebelum melakukan tindakan itu lagi.

Kemampuan
Setiap karakter memiliki 4 slot kemampuan. Jika kemampuan ditulis miring, itu adalah tindakan.

Kemampuan

Nama Keterangan Mana Cooldown 
                                                     Mobility                                                     

Blink         Pindah ke persegi, berbagai 4 2 2 
 Swap          lokasi Swap dengan Target 5 5 
 Teleport      Pindah mana saja 20 5

Dasbor Tingkatkan rentang langkah dengan 1. Diulang                                               
Mobile Step dapat bergerak ke salah satu dari 8 arah                                                  
                                                    Menyerang                                                    

        Slice Cepat dua kali 3 0 
 Weave         Slice semua musuh yang terlihat sekali 15 10

Serap Setiap Iris mencuri 1 atribut utama target Anda. Berlangsung 20 putaran                    
Cleave Each Slice memberikan 1/2 damage ke musuh yang berdekatan                                           
Critital Menambahkan peluang 30% untuk Slice untuk memberikan kerusakan 200%. Diulang                               
Feast Each Slice meningkatkan HP Anda sebesar 3. Diulang                                             
Flexible Can Slice di salah satu dari 8 arah                                                      
Mana mencuri Slice mencuri 2 mana. Diulang                                                           
Irisan Refleksif saat diiris 0 3 
Mulai menambahkan 1 ke kisaran Slice                                                              
Geser Setiap Iris berturut-turut pada target yang sama memberikan 3 kerusakan lebih banyak daripada yang terakhir               
                                                    Status                                                     

Dispel        Menghapus semua status dari Target. Range 2. 20 10 
 Duel          Membekukanmu dan targetmu sampai salah satu dari kalian mati. Rentang 1 25 0 
 Knockout      Anda dan target terpana untuk 1000 ticks berikutnya 10 10 
 Meteor        Semua musuh tertegun untuk 100 ticks berikutnya 25 10 
 Leash         Target dibekukan untuk 2 giliran berikutnya 4 6 
 Poison Poison        musuh untuk 1 HP untuk 5 putaran 5 0 
 Diam      Target dibungkam untuk 5 putaran 5 7 
          Target Lambat diperlambat oleh 40 tick untuk 3 putaran berikutnya 10 5 
 Stun          Target tertegun untuk 300 tick berikutnya 10 10

Dingin Semua karakter lain dalam 2 rentang diperlambat oleh 10 ticks                                
Immune No status dapat diterapkan pada Anda                                                           
                                                    Defensif                                                    

Force Field   Block berikutnya 5 sumber kerusakan. Tidak menumpuk 15 5 
 Ghost         Untuk belokan, semua damage heal 10 10 
 Heal          Heal Target for 20 HP 10 3 
 Restore       Semua unit dikembalikan ke kondisi kesehatan penuh 20 40 
 Shield        Anda tidak dapat diiris hingga giliran berikutnya 3 0

Hindari peluang 25% agar Slice tidak mengenai Anda. Diulang                                         
Pillar Only dapat diiris sekali putaran                                                            
Bangkit Saat Dibunuh, hidupkan kembali dengan HP penuh (dan tanpa status) 0 40 
Paku Ketika menangani kerusakan, berikan setengah dari kerusakan kembali                                           
                                                     Penglihatan                                                      

Cloak         Team menjadi tidak terlihat selama 5 putaran 20 20 
 Sembunyikan          Anda tidak terlihat untuk 5 putaran 4 7 
 Fase         Menjadi tidak terlihat untuk 1 putaran 0 3 
 Track         Target tidak bisa menjadi tidak terlihat, dan mengambil 10% lebih banyak kerusakan. Berlangsung 10 putaran. 5 5

Darkness Enemy sight range berkurang 1. Tumpukan, tetapi tidak bisa di bawah 1.                                 
Penglihatan jauh Kisaran penglihatan meningkat 2. Diulang                                                    
Tak Terlihat Anda tidak terlihat jika Anda memulai giliran dari visi musuh                               
True sight Mengungkap semua unit tersembunyi dalam rentang 2 saat start                                     
                                                     Kerusakan                                                      

Tiriskan         Penawaran 5 kerusakan pada Target dan menyembuhkan diri untuk 5 HP sementara mereka tetap dalam 1 kisaran 10 5 
     Kesepakatan Petir 15 kerusakan untuk semua musuh 20 10 
 K / O           Membunuh target jika target di bawah 20% HP 20 0 
 Trap          Tempatkan jebakan yang tak terlihat. Perangkap memberikan 15 kerusakan saat diinjak. Tumpukan. 10 2 
 Zap           Deal 30 damage ke target 30 5

Penawaran Statis 5 merusak setiap giliran untuk semua musuh dalam 1 rentang. Diulang                       
                                                      Statistik                                                      

Werewolf      Tambahkan 10 ke semua statistik selama 5 putaran 30 25

Buff Gandakan HP pool Anda. Diulang                                                           
Tindakan Pintar memiliki cooldown 20% lebih pendek. Diulang                                             
Berfokus Meningkatkan tingkat regulasi Mana Anda pada Int / 10. Diulang                                  
Regenerasi Meningkatkan laju Regnerasi Anda dengan Strength / 2. Diulang                                 
Tindakan Cerdas biaya 2 mana kurang. Diulang                                                      
Kuat Anda mendapatkan 10 poin atribut. Diulang                                                  
Lemah Anda kehilangan 15 poin atribut. Anda mendapatkan 2 slot kemampuan (ini mengambil salah satunya)                  
                                                      Lain                                                      

Beruang          Dapat memanggil beruang yang memiliki 5 di setiap stat 8 10 
 Klon         Klon sendiri. Membutuhkan dua slot kemampuan. 100 100 
 Steal         Replace this action with musuh tindakan terakhir Target digunakan. Bertahan 10 putaran 5 0 
 Dinding          Buat dinding tidak bisa dilewati pada kotak kosong yang ditargetkan, kisaran 6 10 10 

Status:

• Setrum memungkinkan karakter Anda untuk hanya melakukan tindakan Senyum, dan berlangsung X kutu .
• Bekukan mencegah karakter Anda bergerak, dan berlangsung X berubah.
• Silence mencegah karakter Anda melakukan apa pun selain Smile, Step, atau Slice, dan berlangsung selama X turn.
• Racun merusak karakter Anda untuk kerusakan X untuk giliran Y. Jika Anda menggunakan racun lain, kerusakannya bertambah, dan durasinya diperbarui.
• Lambat menambahkan X ke jumlah kutu di antara belokan Anda. Itu tidak mempengaruhi giliran Anda yang akan datang , hanya berubah setelah.
• Tak terlihat membuatnya jadi kamu tidak bisa dilihat atau dirusak oleh lawanmu. Jika Anda melakukan tindakan selain Langkah atau Senyum, tindakan itu akan dihapus. Jika lawan Anda memiliki kemampuan yang memberi mereka visi tentang Anda, tembus pandang dihapus.

Semua status (kecuali untuk Racun) bertindak secara independen satu sama lain.

Catatan Samping:

• Jika ada ikatan untuk atribut primer, itu diselesaikan sebagai STR> AGI> INT.
• Anda bermain di kisi 10x10. Tim akan ditempatkan di sisi yang berlawanan.
• Persentase tumpukan multiplikasi, kecuali untuk Pintar.

Aturan pengiriman

Anda perlu menerapkan 2 fungsi:

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

Anda juga akan memiliki akses ke tiga variabel (variabel anggota):

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

Itu dia. Di bawah ini Anda dapat menemukan API lengkap, dalam urutan abjad:

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

Di atas adalah semua fungsi yang mungkin Anda butuhkan untuk kiriman Anda. Refleksi tidak diperbolehkan. Jika kiriman tidak valid karena alasan apa pun, harap hapus atau tambahkan "Tidak Valid" ke header. Kiriman Anda tidak boleh memiliki deklarasi paket. Kiriman Anda harus dimuat dalam blok kode multi-baris pertama, dan baris pertama harus memiliki nama file.

Cara menjalankan proyek:

Ada beberapa cara:

1. Unduh file JAR , dan jalankan java -jar Fellowship.jar. Jika Anda ingin mengunduh kiriman lainnya, sampaikan -q 99744. java harus menunjuk ke JDK, bukan JRE.
2. Kloning repo git , dan jalankan gradle run. Anda perlu menginstal gradle, dan jika Anda ingin memberikan argumen, gunakan-PappArgs="['arg1', 'args2']"
3. Kloning repo git , dan kompilasi sendiri. Anda akan membutuhkan library berikut: 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

Jika Anda mengkloning, Anda harus menggunakan --recursiveflag, dan ketika Anda menarik pembaruan, sertakan--recurse-submodules Untuk semua hal di atas, kelas Anda harus masuk ke submissions/javafolder. Jika Anda menggunakan gradle, atau mengompilasinya sendiri, Anda bisa meletakkan kelas di proyek itu sendiri. Anda harus menghapus tanda komentar pada beberapa baris di fungsi utama, dan memperbaruinya untuk menunjuk ke kelas Anda.

Papan angka:

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

Jika Anda memiliki pertanyaan, atau butuh bantuan, komentar di bawah, atau bergabunglah dengan ruang obrolan ! Semoga berhasil dan selamat bersenang - senang

StaticCloud

Awan yang tumbuh mahluk yang melakukan kerusakan statis untuk siapa pun yang mendekat. Terdiri dari:

• 1/3 Bagian yang tak terlihat
  • STR: 5; AGI: 5; INT: 25
  • Klon , Tidak Terlihat , Statis
• 2/3 Bagian yang terlihat
  • STR: 5; AGI: 5; INT: 25
  • Klon , Statis , Statis

Anda dapat menggunakan kembali satu karakter dari sini di tim Anda, selama Anda menambahkan setidaknya satu karakter lagi yang tidak ada di sini.

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

Pemain Templat

Penggunaan Berkisar , Fleksibel , Zap , dan KO . Anda memiliki izin untuk menggunakan set kemampuan ini jika diinginkan.

Jangan ragu untuk menggunakan bot ini sebagai templat untuk membuatnya sendiri.

Ingatlah bahwa Anda perlu mengubah nama file pada baris pertama, serta memilih set kemampuan Anda sendiri.

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

Menggunakan Zap , FarSight * 2, dan Sembunyikan .

Bot ini pengecut. Prioritas utamanya adalah tidak untuk ditargetkan. Untuk itu ia menggunakan penglihatan superiornya untuk melihat di mana musuh berada. Ia menggunakan pengetahuan ini untuk menghindari terlihat saat melacak / mengikuti musuh tanpa terlihat. Jika terlihat, atau bisa dilihat pada belokan berikutnya maka bot akan 'bersembunyi' menjadi tidak terlihat untuk sementara waktu.

Dalam mode pelacakan, dan ada cukup mana dan reset cooldown, maka akan 'Zap' musuh terlihat paling lemah.

Setelah mana turun menjadi 10% maka akan menghindar dari musuh sampai mana dikembalikan. Dengan cara ini, itu dapat zap secepat mungkin pada musuh yang dilacak. Semoga meniadakan setiap regen HP yang dimiliki musuh.

Catatan karena 'Zap' adalah rentang tak terbatas, semua anggota tim akan menargetkan bot yang sama saat bertabrakan.

Saya memiliki varian lain dari ide dasar yang sama ini yang dapat saya tambahkan sebagai jawaban: semuanya memiliki manfaat / kerugian berbeda yang dieksploitasi / diekspos tergantung pada lawan yang ada.

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

TheWalkingDead

Zombies, semua orang mengenal mereka. Mereka tetap dalam kelompok tanpa melakukan apa-apa sampai seseorang muncul. Mereka sulit untuk dibunuh, dan tidak peduli berapa banyak Anda membunuh selalu ada lebih banyak. Dan mereka biasanya muncul entah dari mana tepat di belakang Anda.

• 1 x Zombie # 1 (yang terkuat, dan karenanya alfa zombie)
  • STR: 25; AGI: 5; INT: 15
  • Klon , Bangkit , Kuat
• 2 x Zombie # 2 (tidak ada yang ingin menjadi Zombie # 3 di kredit penutupan, karena itu keduanya mendapat nomor yang sama)
  • STR: 15; AGI: 5; INT: 15
  • Klon , Bangkit , Menyerap

Anda dapat menggunakan kembali satu karakter dari sini di tim Anda, selama Anda menambahkan setidaknya satu karakter lagi yang tidak ada di sini.

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

Yang Kebal

Sebuah tim pejuang tangguh yang dapat bertahan hidup hampir semuanya. Ini menyebabkan banyak timeout, yang sayangnya saya sering tidak menang. Namun, tidak ada pertarungan yang saya lihat tidak dapat dimenangkan, dan ketika tim kalah, sering kali dengan karakter yang masih bertahan.

Pertandingan terberat tim ini adalah melawan Kavaleri Beruang (mereka benar-benar tidak mampu menghapus tim ini, tetapi biasanya menang pada tiebreak karena jumlah mereka yang tipis); Pasukan Rogue (tim agak lemah untuk meracuni); dan Vampir (aku belum sepenuhnya yakin mengapa).

Dalam simulasi, tim hampir selalu berada di urutan pertama atau kedua. Skornya cukup stabil; pemenang biasanya tergantung pada seberapa baik Rogue Squad terhadap pesaing lainnya (penempatannya jauh lebih acak daripada Invulnerables ').

Penyihir di Lingkungan Berbahaya

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

Mage melindungi dirinya sendiri menggunakan combo Pillar and Force Field ; Menjadi Fokus dan memiliki Kecerdasan tinggi, itu meregenerasi mana yang cukup untuk melemparkan Force Field pada cooldown setiap kali. Dengan anggapan bahwa lawan tidak memiliki Agility yang ditingkatkan, mereka dapat melakukannya dengan paling banyak lima Iris per lima putaran, dan lima sumber kerusakan akan diblokir selama periode waktu itu. Dengan kata lain, Mage benar-benar membutuhkan mantra untuk dikalahkan; Mengiris tidak bekerja dengan sendirinya, tidak peduli seberapa bagusnya Anda.

Mage dapat menyerang melalui Slicing selama 25 dalam keadaan darurat, tetapi kebanyakan melemparkan Poison berulang kali, yang sangat mudah terbakar dengan regenerasi MP setinggi ini. Karena Racun memiliki jangkauan yang tak terbatas, hanya dibatasi oleh visi tim, Mage adalah cara tim ini mengalahkan musuh yang sangat berat atau regeneratif HP; anggota tim lainnya mempertahankan visi mereka, sementara Mage menangani jumlah kerusakan kuadratik. Racun pasti berakhir melebihi regenerasi HP mereka pada akhirnya, dan saya tidak perlu khawatir tentang kerusakan statis seperti Paku dalam proses.

Raksasa Clifftop Falconer

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

Pekerjaan utama Falconer adalah mendapatkan sisa visi tim target, sehingga mereka dapat diserang, memeriksa peta dengan mata elang. Far Sight memberikan visi yang cukup sehingga musuh yang mencoba bersembunyi atau melarikan diri biasanya dapat terperangkap oleh rentang visi di sudut peta; itu tidak mudah untuk memberi Falconer landasan. True Sight adalah jalan utama tim ini melawan musuh yang tak terlihat, yang kalau tidak akan mungkin untuk rusak. Menjadi besar, dan dengan demikian Kuat , membuat Falconer sangat tahan terhadap kerusakan, dan mampu membuat irisan berat saat diperlukan. Akhirnya, Falconer dapat melepaskan elang pada kerumunan musuh di bawah, memerintahkan mereka untuk Menenun di antara musuh dan menangani kerusakan besar (35) area.

Selain pekerjaan Falconer yang memburu musuh yang mengelak, dan mempertahankan visi musuh sehingga Mage dapat terus meracuni mereka, kemampuan untuk kadang-kadang menenun untuk 35 adalah kunci untuk berurusan dengan tim kawanan musuh; itu mungkin untuk memukul banyak musuh seperti itu, dan meninggalkan mereka cukup rendah untuk menyelesaikan tim (idealnya dengan Weave lain). Berkerumun adalah strategi yang sangat dikuasai di bawah aturan ini, dan Weave adalah salah satu dari sedikit penghitung yang sebenarnya. Meski begitu, itu tidak benar-benar cukup baik dengan sendirinya.

Trollbone Skullrender

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

Pekerjaan Trollbone adalah untuk menjaga gerombolan musuh ditekan sementara unit lainnya dapat melakukan pekerjaan mereka. Sama seperti Mage, Trollbone memiliki mantra jangkauan tak terbatas di Knockout . Kombo ini sangat cocok dengan Mage's Poison; jika mungkin untuk menghadapi musuh satu per satu (dan melawan banyak tim, itu adalah), Falconer akan mendapatkan visi, Trollbone akan mengejutkan mereka, maka Mage akan menumpuk racun pada mereka, dan mereka akan berakhir mati tanpa kemampuan untuk melakukan apa pun (Knockout bertahan 1000 ticks pada target dan Trollbone meregenerasi cooldown untuk itu sedikit lebih cepat dari itu). Ini juga sangat bagus dalam melindungi Trollbone dari musuh kuat tunggal; mereka tidak bisa melakukan apa pun padanya jika mereka tidak sadar. Tentu saja, menghancurkan tengkorak dengan musuh bertanggung jawab untuk meninggalkan keduanya,untuk setrum dan meracuni (dan banyak status lainnya tidak ada yang peduli). Sebagai karakter yang berfokus pada mantera yang tidak terlalu cenderung secara magis, Trollbone meregenerasi sihir bukan melalui kecerdasan, tetapi dengan meminum darah musuh-musuhnya, melakukan Pencurian Mana dengan setiap serangan; ini memberikan tingkat regenerasi MP yang cukup bagus (dan musuh yang terkejut membuat target mudah untuk mencuri MP dari). Akhirnya, Trollbone sesekali mengamuk dan akan menenun melalui barisan musuh sambil menghancurkan kepala mereka dan meminum darah mereka. Terhadap segerombolan musuh yang cukup besar, ini benar-benar mendapatkan kembali mana, dan itu bisa menghabisi banyak yang Falconer melemah (25 + 35 adalah 60, jadi itu bekerja bahkan jika musuh regenerasi sampai batas tertentu di antara).

Strategi

Tidak seperti banyak tim, saya menaruh banyak fokus ke AI, bukan hanya pembangunan tim. Salah satu aturan mendasar adalah bahwa tim akan selalu mencoba untuk berkelompok jika mereka tidak sibuk melakukan hal lain, membuat mereka lebih sulit untuk dikelilingi dan mampu saling membela. Jika mereka dikerumuni, mereka akan mencoba bersembunyi di sudut. Di sisi lain, jika musuh mencoba melarikan diri atau melarikan diri, mereka berkeliaran di peta, memilih dan melangkah ke sudut acak atau pusat; ini lebih atau kurang menjamin bahwa Falconer akan menemukan target pada akhirnya. Gerakan ini dirancang untuk tidak pernah membiarkan musuh mendapatkan serangan pertama jika memungkinkan; musuh harus berjalan ke Slice range sendiri. Mage akan selalutinggalkan MP untuk Force Field, mencegah kehilangan MP kelelahan (satu-satunya cara ini bisa gagal adalah dengan Absorb, yang bisa melewati Force Field bahkan jika kerusakan tidak). Ini biasanya bukan masalah; biasanya Mage dapat melakukan spam Poison setiap belokan tanpa masalah. Jika tidak diganggu, tim lebih suka mengejar musuh satu per satu, memukau mereka ketika mereka masuk ke penglihatan, kemudian meracuni mereka berulang kali sampai mereka mati. Dengan musuh-musuh lain di sekitar, tim akan mencoba untuk layang-layang mereka jika mungkin, berlarian berputar-putar dan memaksa sebagian besar musuh untuk mengejar, sambil memukau dan meracuni salah satu dari mereka. Masalah utama adalah dengan kawanan, itulah sebabnya ada begitu banyak Menenun di sini, tetapi meskipun begitu tampaknya sulit untuk benar-benar mengalahkan strategi.

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

Pasukan jahat terdiri dari:

• 1 Scout (tetap dalam bayangan sambil menjelajahi peta)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Tak Terlihat , penglihatan jauh
• 2 Assasins (serang musuh dengan racun mematikan)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Racun , Berfokus

Sejauh ini kekuatan terbesar yang bisa digunakan keduanya, adalah memanggil anggota tambahan pasukan untuk mendukung mereka.

Anda dapat menggunakan kembali satu karakter dari sini di tim Anda, selama Anda menambahkan setidaknya satu karakter lagi yang tidak ada di sini.

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

Kelas dasar untuk semua bot saya

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