W tym wyzwaniu zamierzasz stworzyć Drużynę, której celem jest pokonanie wszystkich innych członków społeczności w bitwie.

Drużyna (drużyna) składa się z 3 postaci . Każda postać porusza się niezależnie od reszty swojego zespołu, ale będzie musiała współpracować podczas walki z wrogiem. Zespoły będą stawały naprzeciw siebie w rotacyjny sposób. Wygrane są warte 3 punkty, remisy są warte 1 punkt, a straty są warte 0 punktów.

Postacie mają zdolności. Wybór umiejętności twoich postaci jest jedną z najważniejszych (i zabawnych) części tego KotH . Wszystkie są silne i mogą zniszczyć wroga.

Postacie mają Punkty Zdrowia (HP), a kiedy ich HP trafi (lub spadnie poniżej) 0, umierają . Jeśli wszystkie postacie w drużynie przeciwnika zginą, wygrywasz!

Postacie mają Many. Większość akcji wymaga wykonania Many , a jeśli nie masz dość, ta akcja nie jest dla ciebie dostępna.

Postacie mają opóźnienie skrętu . Określa liczbę tyknięć między każdą turą (zaczyna się od 100). Niższe jest lepsze.

Postacie mają atrybuty . Każda postać ma podstawę 5 w każdym atrybucie, a ty otrzymujesz 20 dodatkowych punktów atrybutów do podziału. Po przypisaniu punktów atrybutów, twój główny atrybut jest ustawiony jako najwyższy atrybut.

Dostępne atrybuty to:

• Siła: Daje 10 maksymalnych HP i 0,5 HP na turę
• Inteligencja: Daje 7 Max Many i .1 Many na turę
• Zwinność: zmniejsza opóźnienie skrętu o 1

Zakresy ruchu, wzroku i zasięgu są następujące (wyśrodkowane wokół 0). Niektóre zakresy są kardynalne , co oznacza, że ​​mogą iść tylko bezpośrednio w górę, w lewo, w prawo lub w dół.

    444
   43334
  4322234
 432111234
 432101234
 432111234
  4322234
   43334
    444

Postacie mają początkową wizję 2. Wizja między graczami tej samej społeczności jest wspólna.

Jak grać

Budowa
Gracze zbudują swoją społeczność. Musisz wykonać następujące kroki :

1. Daj punkty atrybutu każdej postaci . Każda postać zaczyna od 5 w każdej ze statystyk, z dodatkowymi 20 do rozdzielenia między 3.

2. Daj umiejętności każdej postaci . Każda postać zaczyna od 4 miejsc na zdolności, a zdolności domyślnie zajmują 1 miejsce na umiejętność. Niektóre umiejętności są powtarzalne i mogą być wielokrotnie przekazywane postaci. Używanie zestawu umiejętności innego przedłożenia bez zgody właściciela jest niedozwolone.

3. Napisz kod dla swoich botów. Kod musi być w Javie i będzie używany do walki (następny krok)

działania

Wszystkie postacie zaczynają się od 3 standardowych akcji:

1. Krok : Poruszaj swoją postacią w zakresie 1
2. Plasterek : Zaatakuj wroga dla Atrybutu Podstawowego w zasięgu 1
3. Uśmiech : nic nie rób

W turze postaci należy wybrać akcję do wykonania. Akcje mogą mieć koszt many i mogą mieć czas odnowienia, który określa liczbę tur, które musisz poczekać przed ponownym wykonaniem tej akcji.

Zdolności
Każda postać ma 4 miejsca na umiejętności. Jeśli umiejętność jest napisana kursywą, jest to akcja.

Umiejętności

Nazwa Opis Czas odnowienia Many 
                                                     Mobilność                                                     

Mrugnięcie         Przenieś do kwadratu, zasięg 4 2 2 
 Zamień          Zamień miejscami Zamień cel 5 5 
 Teleportuj      Przenieś gdziekolwiek 20 5

Dash Zwiększ zakres kroku o 1. Powtarzalne                                               
Mobile Step może poruszać się w dowolnym z 8 kierunków                                                  
                                                    Napadający                                                    

Szybki         plaster dwa razy 3 0 
 Splot         Pokrój wszystkich widocznych wrogów raz 15 10

Absorbuj każdy plasterek kradnie 1 główny atrybut twojego celu. Trwa 20 tur                    
Rozszczepienie Każdy plasterek zadaje 1/2 obrażeń sąsiednim wrogom                                           
Krytyczny Dodaje 30% szansy, że Plasterek zada 200% obrażeń. Powtarzalne                               
Uczta Każdy plasterek zwiększa twoje HP o 3. Powtarzalne                                             
Elastyczna puszka kroi w dowolnym z 8 kierunków                                                      
Kradzież many Kromka kradnie 2 punkty many. Powtarzalne                                                           
Odruchowy plasterek po pokrojeniu 0 3 
Dystansowy Dodaje 1 do zasięgu plastra                                                              
Zamach Każdy kolejny plasterek tego samego celu zadaje 3 obrażenia więcej niż ostatni               
                                                    Statusy                                                     

Rozproszenie        Usuwa wszystkie statusy z celu. Zasięg 2. 20 10 
 Pojedynek          Zamraża ciebie i twój cel, dopóki jedno z was nie umrze. Zasięg 1 25 0 
 Nokaut      Ty i cel jesteście ogłuszeni na następne 1000 tyknięć 10 10 
 Meteoryt        Wszyscy wrogowie są ogłuszeni na następne 100 tyknięć 25 10 
 Smycz         Cel zostaje zamrożony na 2 kolejne tury 4 6 
 Trucizna        Zatruwa wroga za 1 PŻ na 5 tur 5 0 
 Cisza      Cel jest wyciszony na 5 tur 5 7 
 Powolny          Cel jest spowolniony o 40 tyknięć na kolejne 3 tury 10 5 
 Ogłuszenie          Cel jest ogłuszony na kolejne 300 tyknięć 10 10

Zimno Wszystkie pozostałe postacie w zasięgu 2 są spowolnione o 10 tyknięć                                
Odporność Nie można zastosować żadnego statusu                                                           
                                                    Obronny                                                    

Force Field   Blokuj kolejne 5 źródeł obrażeń. Nie kumuluje się 15 5 
 Duch         Na turę wszystkie obrażenia leczą się 10 10 
 Leczenie          Uzdrawiaj cel za 20 HP 10 3 
 Przywróć       Wszystkie jednostki zostają przywrócone do pełnego zdrowia 20 40 
 Tarcza        Nie możesz zostać pocięty do następnej tury 3 0

Unikanie 25% szans, że plasterek cię nie trafi. Powtarzalne                                         
Filar można pokroić tylko raz na turę                                                            
Wskrzeszony Po zabiciu powróć do życia z pełnym HP (i bez statusów) 0 40 
Kolce Po zadaniu obrażeń zadaj połowę obrażeń z powrotem                                           
                                                     Wizja                                                      

        Zespół peleryny staje się niewidzialny na 5 tur 20 20 
 Ukryj          Jesteś niewidoczny na 5 tur 4 7 
 Faza         Stań się niewidzialny na 1 turę 0 3 
 Tor Tor         nie może stać się niewidzialny i otrzymuje 10% więcej obrażeń. Trwa 10 tur. 5 5

Ciemność Zasięg widzenia wroga zmniejszony o 1. Stosy, ale nie może spaść poniżej 1.                                 
Zasięg widzenia zwiększony o 2. Powtarzalne                                                    
Niewidzialny Jesteś niewidoczny, jeśli zaczynasz swoją turę od pola widzenia wroga                               
Prawdziwy widok Ujawnia wszystkie ukryte jednostki w zasięgu 2 na początku tury                                     
                                                     Uszkodzić                                                      

Drenaż         Zadaje 5 obrażeń Celowi i leczy się za 5 PW, gdy pozostają one w zasięgu 1 10 
 Błyskawica     Zadaj 15 obrażeń wszystkim wrogom 20 10 
 K / O           Zabija cel, jeśli cel jest poniżej 20% HP 20 0 
 Pułapka          Umieść niewidoczną pułapkę. Pułapka zadaje 15 obrażeń po nadepnięciu. Półki na książki. 10 2 
 Zap           Zadaj 30 obrażeń celowi 30 5

Statyczne Zadaje 5 obrażeń w każdej turze wszystkim wrogom w zasięgu 1. Powtarzalne                       
                                                      Statystyki                                                      

Wilkołak      Dodaj 10 do wszystkich statystyk na 5 tur 30 30

Wzmocnij Podwój swoją pulę HP. Powtarzalne                                                           
Sprytne akcje mają o 20% krótszy czas odnowienia. Powtarzalne                                             
Koncentruje się Zwiększa wskaźnik regeneracji many o Int / 10. Powtarzalne                                  
Regeneruj Zwiększa wskaźnik regeneracji o siłę / 2. Powtarzalne                                 
Inteligentne akcje kosztują 2 punkty many mniej. Powtarzalne                                                      
Silny Zyskujesz 10 punktów atrybutów. Powtarzalne                                                  
Słaby Tracisz 15 punktów atrybutów. Zyskujesz 2 miejsca na umiejętności (zajmuje jeden z nich)                  
                                                      Inny                                                      

Niedźwiedź          Może samodzielnie przywołać niedźwiedzia, który ma 5 w każdej ze statystyk 8 10 
 Klon         Klon. Zajmuje dwa miejsca na umiejętności. 100 100 
 Kradzież         Zamień tę akcję na ostatnią akcję Użyty cel wroga. Trwa 10 obrotów 5 0 
 Ściana          Stwórz nieprzejezdną ścianę na docelowym pustym kwadracie, zasięg 6 10 10 

Statusy:

• Ogłuszenie pozwala twojej postaci wykonać tylko akcję Uśmiech i trwa X tyknięć .
• Zamrożenie zapobiega ruchowi twojej postaci i trwa X tur.
• Cisza uniemożliwia twojej postaci wykonywanie innych czynności oprócz Uśmiechu, Kroku lub Kromki i trwa X tur.
• Trucizna uszkadza twoją postać za X obrażeń w turach Y. Jeśli zastosujesz kolejną truciznę, obrażenia sumują się, a czas trwania zostaje odświeżony.
• Powolne dodaje X do liczby tyknięć między twoimi turami. Nie wpływa to na twoją nadchodzącą turę, tylko zwroty później.
• Niewidoczny sprawia, że ​​przeciwnik nie może cię zobaczyć ani uszkodzić. Jeśli wykonasz dowolną czynność oprócz Krok lub Uśmiech, zostanie ona usunięta. Jeśli twój przeciwnik ma zdolność, która daje mu wizję ciebie, niewidzialność jest usuwana.

Wszystkie statusy (oprócz Trucizny) działają niezależnie od siebie.

Notatki dodatkowe:

• Jeśli istnieje remis dla atrybutu podstawowego, jest on rozwiązywany jako STR> AGI> INT.
• Grasz na siatce 10x10. Zespoły zostaną umieszczone po przeciwnych stronach.
• Procenty stosu mnożą się, z wyjątkiem Clever.

Zasady przesyłania

Musisz zaimplementować 2 funkcje:

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

Będziesz także mieć dostęp do trzech zmiennych (zmiennych składowych):

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

Otóż ​​to. Poniżej znajdziesz pełny interfejs API, w kolejności alfabetycznej:

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

Powyższe zawiera wszystkie funkcje, których możesz potrzebować do przesłania. Odbicie nie jest dozwolone. Jeśli przesłanie jest nieważne z jakiegokolwiek powodu, usuń je lub dodaj „Nieprawidłowy” do nagłówka. Twoje zgłoszenie nie powinno zawierać deklaracji pakietu. Twoje zgłoszenie powinno znajdować się w pierwszym wieloliniowym bloku kodu, a pierwszy wiersz musi mieć nazwę pliku.

Jak uruchomić projekt:

Istnieje kilka sposobów:

1. Pobierz plik JAR i uruchom java -jar Fellowship.jar. Jeśli chcesz pobrać inne zgłoszenia, przekaż -q 99744. java musi wskazywać na JDK, a nie JRE.
2. Sklonować repo git i uruchom gradle run. Musisz mieć zainstalowanego gradla, a jeśli chcesz przekazać argumenty, użyj-PappArgs="['arg1', 'args2']"
3. Sklonować repo git i skompilować go samodzielnie. Potrzebne będą następujące biblioteki: 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

Jeśli sklonujesz, musisz użyć --recursiveflagi, a kiedy pobierasz aktualizacje, dołącz--recurse-submodules Do każdego z powyższych, klasa musi przejść do submissions/javafolderu. Jeśli używasz gradla lub kompilujesz go samodzielnie, możesz umieścić klasę w samym projekcie. Musisz odkomentować niektóre linie w głównej funkcji i zaktualizować je, aby wskazywały na twoją klasę.

Tablica wyników:

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

Jeśli masz jakieś pytania lub potrzebujesz pomocy, skomentuj poniżej lub dołącz do czatu ! Powodzenia i miłej zabawy

StaticCloud

Czująca rosnąca chmura, która wyrządza szkody statyczne każdemu, kto się zbliży. Składa się ona z:

• 1/3 Niewidoczna część
  • STR: 5; AGI: 5; INT: 25
  • Klon , niewidoczny , statyczny
• 2/3 Widoczna część
  • STR: 5; AGI: 5; INT: 25
  • Klon , statyczny , statyczny

Możesz ponownie użyć pojedynczych postaci stąd w swoim zespole, o ile dodasz co najmniej jeszcze jedną postać, której tu nie ma.

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

Szablon odtwarzacza

Wykorzystuje zasięg , elastyczność , zap i KO . Jeśli chcesz, masz pozwolenie na użycie tej umiejętności.

Możesz użyć tego bota jako szablonu do tworzenia własnych.

Pamiętaj, że musisz zmienić nazwę pliku w pierwszym wierszu, a także wybrać własny zestaw umiejętności.

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

Używa Zap , FarSight * 2 i Hide .

Ten bot jest tchórzem. Jego najwyższym priorytetem nie można być celem. W tym celu używa swojego wzroku, aby zobaczyć, gdzie są wrogowie. Wykorzystuje tę wiedzę, aby uniknąć bycia widocznym podczas śledzenia / podążania za wrogiem bez bycia widocznym. Jeśli zostanie zauważony lub będzie widoczny w następnej turze, bot „ukryje się”, przez pewien czas będzie niewidoczny.

W trybie śledzenia dostateczna ilość many i resetowania czasu odnowienia spowoduje „Zap” najsłabszego widocznego wroga.

Kiedy mana spadnie do 10%, będzie się unikać wrogów, dopóki nie zostanie przywrócona. W ten sposób może atakować jak najszybciej na wyśledzonym wrogu. Mam nadzieję, że neguje regenerację HP, którą ma wróg.

Uwaga: ponieważ „Zap” ma nieskończony zasięg, wszyscy członkowie zespołu będą celować w tego samego bota podczas zappingu.

Mam inne warianty tej samej podstawowej idei, którą mogę dodać jako odpowiedzi: wszystkie mają różne korzyści / szkody, które są wykorzystywane / narażone w zależności od obecnych przeciwników.

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

Zombie, wszyscy je znają. Pozostają w grupie i nic nie robią, dopóki ktoś się nie pojawi. Trudno je zabić i bez względu na to, ile zabijasz, zawsze jest ich więcej. I zwykle pojawiają się znikąd tuż za twoimi plecami.

• 1 x Zombie # 1 (najsilniejszy, a zatem zombie alfa)
  • STR: 25; AGI: 5; INT: 15
  • Klon , Wskrzeszony , Silny
• 2 x Zombie # 2 (nikt nie chciał być Zombie # 3 w końcowych napisach, dlatego oba mają ten sam numer)
  • STR: 15; AGI: 5; INT: 15
  • Klon , Wskrzeszenie , Absorbowanie

Możesz ponownie użyć pojedynczych postaci stąd w swoim zespole, o ile dodasz co najmniej jeszcze jedną postać, której tu nie ma.

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

Niezniszczalni

Zespół odpornych wojowników, którzy mogą przetrwać prawie wszystko. Prowadzi to do wielu przerw, które niestety często nie wygrywam. Jednak żaden pojedynek, który widziałem, jest nie do pokonania, a kiedy drużyna przegrywa, często przeżywa postacie.

Najtrudniejsze pojedynki tej drużyny toczą się przeciwko Bear Cavalry (dosłownie nie są w stanie wymazać tej drużyny, ale zazwyczaj wygrywają po rozstrzygnięciu remisu ze względu na ich dużą liczbę); Oddział Łotrzyk (drużyna jest nieco słaba na truciznę); i Wampir (nie jestem jeszcze do końca pewien dlaczego).

W symulacjach zespół prawie zawsze zajmuje pierwsze lub drugie miejsce. Jego wynik jest dość stabilny; zwycięzca zwykle zależy od tego, jak dobrze Oddział Łotrzyk poradzi sobie z innymi konkurentami (jego umiejscowienie jest znacznie bardziej losowe niż w przypadku Niewrażliwych).

Mag w szkodliwej sferze

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

Mag chroni się za pomocą kombinacji Pillar i Force Field ; są ukierunkowane i mający wysoką inteligencję, regeneruje wystarczająco dużo many do oddania sił pola na cooldown każdym czasie. Zakładając, że przeciwnicy nie mają zwiększonej Zręczności, mogą w ten sposób trafić go maksymalnie pięcioma Plasterkami na pięć tur, a w tym czasie zablokowanych zostanie pięć źródeł obrażeń. Innymi słowy, Mag absolutnie potrzebuje zaklęć do pokonania; Krojenie nie działa samo z siebie, bez względu na to, jak dobry jesteś.

Mag może zaatakować poprzez Odcinanie do 25 w nagłych wypadkach, ale przede wszystkim rzuca Poison wielokrotnie, co jest bardzo spammable z regeneracji MP to wysokiej. Ponieważ Trucizna ma nieskończony zasięg, ograniczony jedynie przez wizję drużyny, Mag jest sposobem, w jaki drużyna ta pokonuje bardzo ciężkich lub regenerujących się wrogów; reszta drużyny utrzymuje na nich wzrok, a Mag zadaje kwadratowe obrażenia. Trucizna ostatecznie nieuchronnie przewyższa regenerację HP, a ja nie muszę się martwić o uszkodzenia statyczne, takie jak Kolce.

Giant Clifftop Falconer

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

Głównym zadaniem Falconera jest zdobycie reszty wizji zespołu celów, aby mogli zostać zaatakowani, badając mapę oczami sokoła. Daleki widok daje wystarczającą widoczność, że wrogowie, którzy próbują się ukryć lub uciec, mogą normalnie zostać uwięzieni przez zasięg widzenia w rogu mapy; niełatwo jest dać Falconerowi rozwiązanie. True Sight jest głównym sposobem ucieczki tej drużyny przed niewidzialnymi wrogami, którzy w przeciwnym razie nie byliby w stanie zranić. Będąc dużym, a tym samym Silnym , sprawia, że ​​Sokolnik jest bardzo odporny na uszkodzenia i zdolny do ciężkich cięć w razie potrzeby. Wreszcie, Sokolnik może uwolnić swoje sokoły na tłumie wroga poniżej, nakazując im Tkać się wśród wroga i zadając ogromne (35) obrażeń obszarowych.

Oprócz pracy Sokolnika, polegającej na ściganiu uciekających wrogów i utrzymywaniu wizji wrogów, tak aby Mag mógł ich nadal zatruwać, umiejętność Od czasu do czasu Tkania za 35 jest kluczem do radzenia sobie z drużynami wroga; w ten sposób można trafić wielu wrogów i pozostawić ich wystarczająco nisko, aby reszta drużyny mogła zakończyć (najlepiej z innym splotem). Rój jest prawie obezwładnioną strategią na tych zasadach, a Weave jest jednym z niewielu prawdziwych liczników, jakie posiada. Nawet wtedy sam w sobie nie jest wystarczająco dobry.

Trollbone Skullrender

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

Zadaniem Trollbone jest tłumienie wrogich hord, podczas gdy inne jednostki mogą wykonywać swoje zadania. Podobnie jak Mag, Trollbone posiada zaklęcie o nieskończonym zasięgu w Knockout . To bardzo dobrze łączy się z Trucizną Maga; jeśli kiedykolwiek będzie można stawić czoła wrogowi jeden po drugim (i to przeciwko wielu drużynom), Sokolnik zyska widzenie, Trollbone ogłuszy ich, a następnie Mag nałoży na nich truciznę, a skończą martwi bez umiejętności robienia czegokolwiek (nokaut trwa 1000 tyknięć na celu, a Trollbone regeneruje czas odnowienia nieco szybciej). Jest również bardzo dobry w ochronie Trollbone przed pojedynczymi silnymi wrogami; nie mogą mu nic zrobić, jeśli nie są przytomni. Oczywiście, rozbicie czaszek wrogiem może spowodować, że oba zostaną wstrząśnięte,ogłuszyć i otruć (i kilka innych statusów, o które nikt nie dba). Jako postać skupiona na zaklęciach, która jednak nie jest zbyt magicznie skłonna, Trollbone regeneruje magię nie poprzez inteligencję, ale poprzez picie krwi swoich wrogów, wykonując Kradzież Many przy każdym trafieniu; daje to całkiem niezłą szybkość regeneracji PM (a ogłuszeni wrogowie ułatwiają kradzież PM). Wreszcie Trollbone czasami idzie w szał i Weave przez szeregi wroga podczas rozbijania głowami i picia ich krwi. Przeciw dostatecznie dużemu rojowi wrogów odzyskuje manę i może wykończyć rój osłabiony przez Sokolnika (25 + 35 to 60, więc działa, nawet jeśli wrogowie regenerują się do pewnego stopnia pomiędzy nimi).

Strategia

W przeciwieństwie do wielu drużyn, skupiam się na sztucznej inteligencji, a nie tylko na budowaniu zespołów. Jedną z podstawowych zasad jest to, że drużyna zawsze będzie próbować grupować się, jeśli nie będzie zajęta robieniem czegoś innego, co utrudni ich otoczenie i będzie w stanie się bronić. Jeśli zostaną rojowani, spróbują ukryć się w kącie. Z drugiej strony, jeśli wróg próbuje uciec lub uciec, wędruje po mapie, zbierając i kierując do losowych zakrętów lub centrum; to mniej więcej gwarantuje, że Sokolnik ostatecznie zauważy cel. Ruch jest zaprojektowany tak, aby nigdy nie pozwolić wrogowi na pierwsze uderzenie, jeśli to możliwe; wróg będzie musiał sam wejść w zasięg Kromki. Mag zawszezostaw MP na pole siłowe, zapobiegając utracie wyczerpania MP (jedyny sposób, w jaki może się to nie udać, to Absorbowanie, które może przedostać się przez Pole Mocy, nawet jeśli obrażenia nie). Zwykle nie stanowi to problemu; zazwyczaj Mag może spamować Truciznę w każdej turze bez problemów. Jeśli nie przeszkadza mu to, drużyna woli ścigać wrogów pojedynczo, ogłuszając ich, gdy pojawiają się w polu widzenia, a następnie trując ich wielokrotnie, aż do śmierci. Podczas gdy inni wrogowie są w pobliżu, drużyna będzie próbowała je latać, jeśli to możliwe, biegając w kółko i zmuszając większość wrogów do ścigania, jednocześnie oszałamiając i zatruwając jednego z nich. Główny problem związany jest z rojami, dlatego tkwi tu tak wiele Tkania, ale nawet wtedy wydaje się, że trudno pokonać 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

Drużyna łotrzyków składa się z:

• 1 Zwiadowca (pozostaje w cieniu podczas eksploracji mapy)
  • STR: 5; AGI: 5; INT: 25
  • Klon , niewidoczny , daleki wzrok
• 2 zabójców (atakuj wrogów śmiertelną trucizną)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Trucizna , Koncentruje się

Zdecydowanie największa moc, jaką obaj mogą użyć, to wezwać dodatkowych członków drużyny, aby ich wspierali.

Możesz ponownie użyć pojedynczych postaci stąd w swoim zespole, o ile dodasz co najmniej jeszcze jedną postać, której tu nie ma.

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

Klasa podstawowa dla wszystkich moich botów

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