In dieser Herausforderung erstellen Sie eine Gemeinschaft mit dem Ziel, alle anderen Gemeinschaften im Kampf zu besiegen.

Ein Fellowship (Team) besteht aus 3 Charakteren . Jeder Charakter bewegt sich unabhängig vom Rest seines Teams, aber er muss zusammenarbeiten, wenn er gegen seinen Feind kämpft. Die Teams stehen sich rotierend gegenüber. Siege sind 3 Punkte wert, Unentschieden 1 Punkt und Verluste 0 Punkte.

Charaktere haben Fähigkeiten. Die Auswahl der Fähigkeiten Ihrer Charaktere ist einer der wichtigsten (und unterhaltsamsten) Aspekte dieser KotH . Sie sind alle stark und haben das Potenzial, Ihren Feind auszulöschen.

Charaktere haben Lebenspunkte (HP) und wenn ihre HP 0 erreichen (oder unterschreiten), sterben sie . Wenn alle Charaktere in der gegnerischen Mannschaft sterben, haben Sie gewonnen!

Charaktere haben Mana. Die meisten Aktionen erfordern Mana , und wenn Sie nicht genug haben, steht Ihnen diese Aktion nicht zur Verfügung.

Charaktere haben eine Turn-Verzögerung . Dies bestimmt die Anzahl der Ticks zwischen jeder Runde (beginnt bei 100). Weniger ist besser.

Charaktere haben Attribute . Jeder Charakter hat eine Basis von 5 in jedem Attribut und Sie erhalten 20 zusätzliche Attributpunkte zum Teilen. Nach dem Zuweisen von Attributpunkten wird Ihr primäres Attribut als höchstes Attribut festgelegt.

Verfügbare Attribute sind:

• Stärke: Gewährt 10 HP und 0,5 HP pro Spielzug
• Intelligenz: Gewährt 7 max. Mana und 0,1 Mana pro Spielzug
• Beweglichkeit: Reduziert die Abbiegeverzögerung um 1

Bewegung, Sicht und Reichweite
sind wie folgt (zentriert um die 0). Einige Bereiche sind kardinal , was bedeutet, dass sie nur direkt nach oben, links, rechts oder unten gehen können.

    444
   43334
  4322234
 432111234
 432101234
 432111234
  4322234
   43334
    444

Charaktere haben eine Startvision von 2. Die Vision zwischen Spielern der gleichen Gemeinschaft wird geteilt.

Spielanleitung

Aufbau
Spieler werden ihre Gemeinschaft aufbauen. Sie müssen die folgenden Schritte ausführen :

1. Geben Sie jedem Charakter Attributpunkte . Jeder Charakter beginnt mit 5 in jeder Statistik, wobei weitere 20 auf die 3 verteilt werden.

2. Gib jedem Charakter Fähigkeiten . Jeder Charakter beginnt mit 4 Fähigkeitsfeldern, und Fähigkeiten nehmen standardmäßig 1 Feld ein. Einige Fähigkeiten sind wiederholbar und können einem Charakter mehrmals gegeben werden. Die Verwendung eines Fähigkeitssatzes eines anderen Beitrags ohne die Erlaubnis des Besitzers ist nicht gestattet.

3. Schreiben Sie Code für Ihre Bots. Der Code muss in Java sein und wird zum Kämpfen verwendet (der nächste Schritt)

Aktionen

Alle Charaktere beginnen mit den 3 Standardaktionen:

1. Schritt : Bewegen Sie Ihren Charakter in einen Kardinalbereich von 1
2. Slice : Greife einen Gegner für PrimaryAttribute in einem Kardinalbereich von 1 an
3. Lächeln : Nichts tun

Wenn ein Charakter an der Reihe ist, muss er eine Aktion auswählen, die ausgeführt werden soll. Aktionen können Manakosten und eine Abklingzeit haben, die die Anzahl der Runden definiert, die Sie warten müssen, bevor Sie diese Aktion erneut ausführen.

Fähigkeiten
Jeder Charakter hat 4 Fähigkeitsfelder. Wenn eine Fähigkeit kursiv gedruckt ist, handelt es sich um eine Aktion.

Fähigkeiten

Name Beschreibung Mana Abklingzeit 
                                                     Mobilität                                                     

Blink         Umzug in ein Quadrat, Bereich 4 2 2 
 Swap          Swap Standorte mit Ziel 5 5 
 Teleportation      Bewegen überall 20 5

Strich Erhöhen Sie die Schrittweite um 1. Wiederholbar                                               
Mobile Step kann sich in jede der 8 Richtungen bewegen                                                  
                                                    Angreifen                                                    

Schneller         Schnitt zweimal 3 0 
 Weben         Schneiden Sie alle sichtbaren Feinde einmal 15 10

Absorbieren Jede Scheibe stiehlt 1 der primären Attribute Ihres Ziels. Hält 20 Runden                    
Jede Scheibe spalten fügt benachbarten Gegnern 1/2 Schaden zu                                           
Kritisch Erhöht die Chance, dass 'Scheibe' 200% Schaden verursacht, um 30%. Wiederholbar                               
Schlemmen Sie jede Scheibe, um Ihre HP um 3 zu erhöhen. Wiederholbar                                             
Flexible Can Slice in eine der 8 Richtungen                                                      
Mana stehlen Slice stiehlt 2 Mana. Wiederholbar                                                           
Reflexive Scheibe in Scheiben 0 3 
Fernkampf Erhöht die Reichweite von Slice um 1                                                              
Streichen Jedes aufeinanderfolgende Stück auf demselben Ziel verursacht 3 Schadenspunkte mehr als das letzte               
                                                    Status                                                     

Zerstreuen        Entfernt alle Status von einem Ziel. Reichweite 2. 20 10 
 Duell          Friert dich und dein Ziel ein, bis einer von dir stirbt. Reichweite 1 25 0 
 Ko      Sie und das Ziel sind für die nächsten 1000 Ticks betäubt. 10 10 
 Meteor        Alle Feinde sind für die nächsten 100 Ticks betäubt. 25 10 
 Leine Das         Ziel ist für die nächsten 2 Runden eingefroren. 4 6 
 Gift vergiftet        den Gegner für 1 HP für 5 Runden 5 0 
 Stille      Das Ziel wird für 5 Runden zum Schweigen gebracht. 5 7 
 Langsam Das          Ziel wird für die nächsten 3 Runden um 40 Ticks verlangsamt. 10 5 
 Betäubt Das          Ziel wird für die nächsten 300 Ticks betäubt. 10 10

Kalt Alle anderen Zeichen innerhalb des Bereichs 2 werden um 10 Ticks verlangsamt                                
Immun Es kann kein Status auf Sie angewendet werden                                                           
                                                    Defensive                                                    

Force Field   Block nächsten 5 Schadensquellen. Nicht gestapelt 15 5 
 Geist         Für eine Runde heilt jeder Schaden 10 10 
 Heilen          Heilen Ziel für 20 HP 10 3 
 Wiederherstellen       Alle Einheiten sind wieder in vollem Zustand 20 40 
 Schild        Sie können erst in Ihrer nächsten Runde in Scheiben geschnitten werden 3 0

Ausweichchance von 25%, dass ein Slice Sie nicht trifft. Wiederholbar                                         
Pillar Only kann einmal pro Runde geschnitten werden                                                            
Auferstehen Wenn Sie getötet wurden, werden Sie mit voller HP (und ohne Status) wieder lebendig. 0 40 
Spikes Wenn Sie Schaden zugefügt haben, geben Sie die Hälfte des Schadens zurück                                           
                                                     Vision                                                      

Mantel -         Team wird unsichtbar für 5 Umdrehungen 20 20 
 Verstecken          Sie sind unsichtbar für 5 Umdrehungen 4 7 
 Phase         für 1 Umdrehung 0 3 unsichtbar 
 Spur         Ziel kann nicht unsichtbar gehen, und nimmt 10% mehr Schaden. Hält 10 Runden. 5 5

Die Sichtweite von Darkness Enemy wurde um 1 verringert. Sie kann jedoch nicht unter 1 fallen.                                 
Fernsicht Sichtweite um 2 erhöht. Wiederholbar                                                    
Unsichtbar Sie sind unsichtbar, wenn Sie sich aus der Sicht des Feindes entfernen                               
Wahre Sicht Enthüllt alle versteckten Einheiten in Reichweite 2 beim Start der Runde                                     
                                                     Beschädigung                                                      

Entleeren         Fügt dem Ziel 5 Schadenspunkte zu und heilt sich selbst um 5 HP, solange es sich in 1 Reichweite befindet. 10 5 
 Blitzschlag     Fügt allen Gegnern 15 Schadenspunkte zu. 20 10 
 K / O           Tötet das Ziel, wenn das Ziel unter 20% HP liegt. 20 0 
 Falle          Platziert eine unsichtbare Falle. Die Falle fügt beim Betreten 15 Schadenspunkte zu. Stapel. 10 2 
 Zap           Füge dem Ziel 30 Schaden zu. 5

Statisch Fügt allen Gegnern in 1 Reichweite pro Runde 5 Schadenspunkte zu. Wiederholbar                       
                                                      Statistiken                                                      

Werwolf      Addiere 10 zu allen Statistiken für 5 Runden 30 25

Buff Verdopple deinen HP-Pool. Wiederholbar                                                           
Kluge Aktionen haben eine um 20% kürzere Abklingzeit. Wiederholbar                                             
Konzentriert Erhöht Eure Manaregeration um Int / 10. Wiederholbar                                  
Regenerieren Erhöht Eure Regenerationsrate um Stärke / 2. Wiederholbar                                 
Intelligente Aktionen kosten 2 Mana weniger. Wiederholbar                                                      
Stark Sie erhalten 10 Attributpunkte. Wiederholbar                                                  
Schwach Sie verlieren 15 Attributpunkte. Du erhältst 2 Fähigkeits-Slots (dies nimmt einen von ihnen)                  
                                                      Andere                                                      

Bär          Kann einen Bären beschwören, der jeweils 5 Punkte enthält. 8 10 
 Klon         Klonen Sie sich. Nimmt zwei Fähigkeitsplätze ein. 100 100 
 Steal         Ersetze diese Aktion durch die zuletzt verwendete Aktion des Gegners Target. Hält 10          Runden an 5 0 
 Mauer Erstelle eine unpassierbare Mauer auf einem leeren Zielfeld, Reichweite 6 10 10 

Status:

• Durch Betäuben kann dein Charakter nur die Aktion „Lächeln“ ausführen und hält X Ticks an .
• Einfrieren verhindert, dass sich dein Charakter bewegt, und dauert X Runden.
• Die Stille verhindert, dass dein Charakter etwas anderes als Lächeln, Schritt oder Slice ausführt, und hält X Runden lang an.
• Gift beschädigt deinen Charakter für X Schaden für Y Runden. Wenn Sie ein anderes Gift anwenden, addiert sich der Schaden und die Dauer wird aktualisiert.
• Langsam erhöht die Anzahl der Ticks zwischen Ihren Zügen um X. Es wirkt sich nicht auf Ihre bevorstehende Runde aus, sondern erst danach.
• Unsichtbar macht es so, dass Sie von Ihrem Gegner nicht gesehen oder beschädigt werden können. Wenn Sie eine andere Aktion als "Schritt" oder "Lächeln" ausführen, wird diese entfernt. Wenn dein Gegner eine Fähigkeit hat, die ihm eine Vision von dir gibt, wird die Unsichtbarkeit entfernt.

Alle Status (mit Ausnahme von Poison) sind unabhängig voneinander.

Randnotizen:

• Wenn für das primäre Attribut ein Gleichstand besteht, wird es als STR> AGI> INT aufgelöst.
• Du spielst auf einem 10x10 Gitter. Die Mannschaften werden auf entgegengesetzte Seiten gestellt.
• Die Prozentsätze werden multiplikativ gestapelt, mit Ausnahme von Clever.

Einreichungsregeln

Sie müssen 2 Funktionen implementieren:

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

Sie haben auch Zugriff auf drei Variablen (Mitgliedsvariablen):

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

Das ist es. Nachfolgend finden Sie eine vollständige API in alphabetischer Reihenfolge:

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

Das Obige sind alle Funktionen, die Sie möglicherweise für Ihre Einreichung benötigen könnten. Reflexion ist nicht erlaubt. Wenn eine Einsendung aus irgendeinem Grund ungültig ist, entfernen Sie sie bitte oder fügen Sie "Ungültig" in die Kopfzeile ein. Ihre Einreichung sollte keine Paketdeklaration enthalten. Ihre Einreichung sollte im ersten mehrzeiligen Codeblock enthalten sein, und die erste Zeile muss den Dateinamen haben.

So führen Sie das Projekt aus:

Es gibt verschiedene Möglichkeiten:

1. Laden Sie die JAR-Datei herunter und führen Sie sie aus java -jar Fellowship.jar. Wenn Sie andere Beiträge herunterladen möchten, übergeben Sie -q 99744. java muss auf das JDK verweisen, nicht auf das JRE.
2. Klonen Sie das Git-Repo und führen Sie es aus gradle run. Sie müssen gradle installiert haben, und wenn Sie Argumente übergeben möchten, verwenden Sie-PappArgs="['arg1', 'args2']"
3. Klonen Sie das Git Repo und kompilieren Sie es selbst. Sie werden die folgenden Bibliotheken müssen: 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

Wenn Sie klonen, müssen Sie das --recursiveFlag verwenden und beim Abrufen von Aktualisierungen Folgendes einschließen:--recurse-submodules In einem der oben genannten Fälle muss Ihre Klasse in den submissions/javaOrdner verschoben werden. Wenn Sie gradle verwenden oder selbst kompilieren, können Sie die Klasse in das Projekt selbst einfügen. Sie müssen einige Zeilen in der Hauptfunktion auskommentieren und aktualisieren, um auf Ihre Klasse zu verweisen.

Anzeigetafel:

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

Wenn Sie Fragen haben oder Hilfe benötigen, kommentieren Sie unten oder treten Sie dem Chatraum bei ! Viel Glück und hab Spaß

StaticCloud

Eine fühlende, wachsende Wolke, die jedem, der sich nähert, statischen Schaden zufügt. Es besteht aus:

• 1/3 Unsichtbarer Teil
  • STR: 5; AGI: 5; INT: 25
  • Klon , unsichtbar , statisch
• 2/3 Sichtbarer Teil
  • STR: 5; AGI: 5; INT: 25
  • Klon , statisch , statisch

Sie können einzelne Zeichen von hier in Ihrem Team wiederverwenden, solange Sie mindestens ein weiteres Zeichen hinzufügen, das hier nicht vorhanden ist.

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

Template-Player

Verwendet Fernkampf , Flexibel , Zap und KO . Sie haben die Berechtigung, diesen Fähigkeitssatz zu verwenden, wenn Sie dies wünschen.

Fühlen Sie sich frei, diesen Bot als Vorlage für die Erstellung Ihrer eigenen zu verwenden.

Denken Sie daran, dass Sie den Dateinamen in der ersten Zeile ändern und Ihre eigenen Fähigkeiten auswählen müssen.

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

Verwendet Zap , FarSight * 2 und Hide .

Dieser Bot ist ein Feigling. Ihre höchste Priorität ist nicht anzustreben. Zu diesem Zweck nutzt er seine überlegene Sicht, um zu sehen, wo Feinde sind. Es nutzt dieses Wissen, um zu vermeiden, gesehen zu werden, während es den Feind verfolgt, ohne gesehen zu werden. Wenn es gesehen wird oder in der nächsten Runde gesehen werden könnte, wird der Bot für eine Weile unsichtbar.

Im Verfolgungsmodus und wenn genügend Mana und Abklingzeit zurückgesetzt sind, wird der schwächste sichtbare Feind "zappen".

Sobald das Mana auf 10% gesunken ist, scheuen Sie sich vor Feinden, bis das Mana wiederhergestellt ist. Auf diese Weise kann es auf verfolgte Gegner so schnell wie möglich zappen. Hoffentlich annulliere ich jegliche HP-Regeneration, die der Gegner hat.

Da "Zap" eine unendliche Reichweite hat, zielen alle Teammitglieder beim Zappen auf denselben Bot.

Ich habe andere Varianten der gleichen Grundidee, die ich als Antwort hinzufügen kann: Sie haben alle unterschiedliche Vorteile / Nachteile, die je nach den anwesenden Gegnern ausgenutzt / aufgedeckt werden.

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

DIe laufenden Toten

Zombies kennt jeder. Sie bleiben in einer Gruppe und tun nichts, bis jemand auftaucht. Sie sind schwer zu töten, und egal wie viele du tötest, es gibt immer mehr. Und sie erscheinen normalerweise aus dem Nichts direkt hinter Ihrem Rücken.

• 1 x Zombie # 1 (der stärkste und damit der Alpha-Zombie)
  • STR: 25; AGI: 5; INT: 15
  • Klonen , auferstehen , stark
• 2 x Zombie # 2 (niemand wollte Zombie # 3 im Abspann sein, daher bekamen beide die gleiche Nummer)
  • STR: 15; AGI: 5; INT: 15
  • Clone , Resurrect , absorbieren

Sie können einzelne Zeichen von hier in Ihrem Team wiederverwenden, solange Sie mindestens ein weiteres Zeichen hinzufügen, das hier nicht vorhanden ist.

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

Die Unverwundbaren

Ein Team von robusten Kriegern, die fast alles überleben können. Dies führt zu vielen Auszeiten, die ich leider oft nicht gewinne. Allerdings ist kein Matchup, das ich gesehen habe, nicht zu gewinnen, und wenn das Team verliert, gibt es häufig noch überlebende Charaktere.

Die härtesten Kämpfe dieses Teams finden gegen die Bären-Kavallerie statt (sie sind buchstäblich nicht in der Lage, dieses Team zu vernichten, gewinnen aber normalerweise im Unentschieden aufgrund ihrer bloßen Anzahl). die Rogue Squad (das Team ist etwas schwach zu vergiften); und der Vampir (ich weiß noch nicht genau warum).

In Simulationen steht das Team fast immer an erster oder zweiter Stelle. Die Punktzahl ist ziemlich stabil; Der Gewinner hängt normalerweise davon ab, wie gut Rogue Squad gegen die anderen Konkurrenten abschneidet (seine Platzierung ist viel zufälliger als die der Unverwundbaren).

Der Magier in der schädlichen Sphäre

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

Der Magier schützt sich durch die Kombination aus Pfeiler und Kraftfeld . wobei Konzentriert und eine hohe Intelligenz hat, regeneriert es genug Manas Force Field Abklingzeit jeder Zeit. Unter der Annahme, dass die Gegner keine erhöhte Beweglichkeit haben, können sie diese also mit höchstens fünf Scheiben pro fünf Runden treffen, und fünf Schadensquellen werden in diesem Zeitraum blockiert. Mit anderen Worten, der Magier benötigt unbedingt Zaubersprüche, um zu besiegen. Das Schneiden funktioniert nicht von alleine, egal wie gut Sie darin sind.

Der Magier kann im Notfall 25 Sekunden lang über Slicing angreifen , wirkt jedoch meistens wiederholt Gift , was bei einer so hohen MP-Regeneration sehr spammbar ist. Da Poison eine unendliche Reichweite hat, die nur durch die Vision des Teams begrenzt ist, schlägt der Magier dieses Team sehr HP-schwere oder regenerative Gegner. Der Rest des Teams behält die Sicht auf sie, während der Magier quadratisch Schaden zufügt. Das Gift übertrifft schließlich unweigerlich die HP-Regeneration, und ich muss mir keine Sorgen um statische Schäden wie Spikes machen.

Der riesige Klippenfalkner

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

Die Hauptaufgabe des Falkners ist es, den Rest der Teamvision von Zielen zu erhalten, damit diese angegriffen werden können, indem die Karte mit den Augen eines Falken abgesucht wird. Far Sight gibt genug Vision , dass Feinde , die versuchen sich zu verstecken oder laufen weg normalerweise durch die Vision Bereich der Karte in einer Ecke gefangen werden; Es ist nicht sehr einfach, dem Falkner den Umweg zu geben. True Sight ist der Hauptregress dieses Teams gegen unsichtbare Feinde, denen sonst kein Schaden zugefügt werden kann. Durch seine Größe und damit Stärke ist der Falkner sehr unempfindlich gegen Beschädigungen und kann bei Bedarf schwere Schnitte ausführen. Schließlich kann der Falkner seine Falken auf die feindlichen Massen unter sich loslassen, um sie zu zwingen, sich unter den Feinden zu weben und massiven Flächenschaden zu verursachen.

Zusätzlich zu der Aufgabe des Falkners, ausweichende Feinde zu jagen und die Sicht der Feinde aufrechtzuerhalten, damit der Magier sie weiterhin vergiften kann, ist die Fähigkeit, gelegentlich 35 Sekunden lang zu weben, der Schlüssel zum Umgang mit feindlichen Schwarmteams. Es ist möglich, auf diese Weise viele Feinde zu treffen und sie niedrig genug zu lassen, damit der Rest des Teams endet (idealerweise mit einer anderen Webart). Schwärmen ist nach diesen Regeln eine ziemlich überwältigende Strategie, und Weave ist einer der wenigen wirklichen Marken, die es gibt. Selbst dann ist es nicht gut genug für sich.

Trollbone-Schädelrender

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

Trollbones Aufgabe ist es, die feindlichen Horden zu unterdrücken, während die anderen Einheiten ihre Arbeit erledigen können. Genau wie der Magier hat Trollbone in Knockout einen Zauber mit unendlicher Reichweite . Dies passt sehr gut zum Gift des Magiers. Wenn es jemals möglich ist, sich dem Feind einzeln zu stellen (und gegen viele Teams ist dies der Fall), wird der Falkner die Sicht erlangen, Trollbone wird sie betäuben, dann wird der Magier Gift auf sie stapeln und sie werden tot enden ohne die Fähigkeit, irgendetwas zu tun (Knockout hält 1000 Ticks auf dem Ziel und Trollbones regeneriert die Abklingzeit dafür etwas schneller). Es ist auch sehr gut darin, Trollbone vor einzelnen starken Feinden zu schützen. Sie können ihm nichts antun, wenn sie nicht bei Bewusstsein sind. Natürlich kann das Zerschlagen von Schädeln mit einem Feind dazu führen, dass beide betroffen sind.betäuben und vergiften (und ein paar andere Status, die niemand interessiert). Als Zauber-fokussierten Charakter, der dennoch nicht sehr magisch geneigt ist, regeneriert Trollbone Magie nicht durch Intelligenz, sondern durch das Blut seiner Feinde zu trinken, tut ein Mana Steal bei jedem Treffer; Dies gibt eine ziemlich gute Geschwindigkeit der MP-Regeneration (und betäubte Feinde sind einfache Ziele, von denen MP gestohlen werden können). Schließlich geht Trollbone gelegentlich auf Raubzug und Weave den feindlichen Reihen durch , während ihre Köpfe zertrümmert und ihr Blut zu trinken. Gegen einen ausreichend großen Schwarm von Feinden gewinnt dieser tatsächlich Mana zurück und kann einen Schwarm beenden, den der Falkner geschwächt hat (25 + 35 ist 60, funktioniert also auch, wenn sich die Feinde in gewissem Maße dazwischen regenerieren).

Strategie

Im Gegensatz zu vielen anderen Teams habe ich viel Wert auf die KI gelegt, nicht nur auf das Teambuilding. Eine grundlegende Regel ist, dass das Team immer versucht, sich zu gruppieren, wenn es nicht gerade beschäftigt ist, etwas anderes zu tun, was es für sie schwieriger macht, sich zu umgeben und sich gegenseitig zu verteidigen. Wenn sie schwärmen, werden sie versuchen, sich in einer Ecke zu verstecken. Versucht der Feind zu fliehen oder zu fliehen, durchstreift er die Karte und sucht nach zufälligen Ecken oder in der Mitte. dies garantiert mehr oder weniger, dass der Falkner irgendwann ein Ziel entdeckt. Die Bewegung ist so konzipiert, dass der Feind nach Möglichkeit niemals den ersten Schlag erhält. Der Feind muss sich selbst in die Slice-Reichweite begeben. Der Magier wird es immer tunBelassen Sie MP für Force Field, um einen Verlust an MP-Erschöpfung zu verhindern (der einzige Weg, auf dem dies fehlschlagen kann, ist Absorbieren, das ein Force Field durchdringen kann, auch wenn der Schaden dies nicht tut). Dies ist normalerweise kein Problem. Normalerweise kann der Magier Gift in jeder Runde ohne Probleme als Spam versenden. Wenn es nicht gestört wird, zieht es das Team vor, Gegner einzeln zu jagen, sie zu betäuben, wenn sie in Sicht kommen, und sie dann wiederholt zu vergiften, bis sie sterben. Wenn andere Feinde in der Nähe sind, wird das Team versuchen, sie zu kiten, indem es im Kreis herumläuft und die meisten Feinde zur Jagd zwingt, während es einen von ihnen betäubt und vergiftet. Das Hauptproblem sind Schwärme, weshalb hier so viel gewebt wird, aber selbst dann scheint es schwer, die Strategie tatsächlich zu übertreffen.

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

Ein Schurken-Trupp besteht aus:

• 1 Scout (bleibt im Schatten, während die Karte erkundet wird)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Unsichtbar , Weitblick
• 2 Assasins ( Greife Feinde mit tödlichem Gift an)
  • STR: 5; AGI: 5; INT: 25
  • Klon , Gift , fokussiert

Die mit Abstand größte Kraft, die beide nutzen können, ist es, zusätzliche Mitglieder des Trupps zu rufen, um sie zu unterstützen.

Sie können einzelne Zeichen von hier in Ihrem Team wiederverwenden, solange Sie mindestens ein weiteres Zeichen hinzufügen, das hier nicht vorhanden ist.

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

Basisklasse für alle meine Bots

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