이 도전에서, 당신은 친교 를 만들 것입니다 전투에서 다른 모든 친교를 물리 치기 것입니다.

친교 (팀)는 3 자로 구성됩니다 . 각 캐릭터는 다른 팀과 독립적으로 움직이지만 적과 싸울 때 함께 일해야합니다. 팀은 서로 마주보고 회전합니다. 승은 3 점, 동점은 1 점, 손실은 0 점입니다.

캐릭터는 능력이 있습니다. 캐릭터가 가진 능력의 선택은이 KotH에서 가장 중요하고 재미있는 부분 중 하나입니다 . 그것들은 모두 강하고 적을 쓸어 낼 수 있습니다.

캐릭터의 체력은 (HP)이고, 체력이 0 이하일 때 죽습니다 . 상대 팀의 모든 캐릭터가 죽으면 승리합니다!

캐릭터에는 마나가 있습니다. 대부분의 작업에는 Mana가 수행해야하며 , 충분하지 않으면 해당 작업을 사용할 수 없습니다.

캐릭터는 턴 지연이 있습니다. 각 턴 사이의 틱 수를 결정합니다 (100에서 시작). 낮을수록 좋습니다.

문자에는 속성이 있습니다. 각 캐릭터는 각 속성에 밑이 ​​5이며, 분할 할 속성 포인트가 20 개 더 있습니다. 속성 포인트를 할당하면 기본 속성 이 가장 높은 속성으로 설정됩니다.

사용 가능한 속성은 다음과 같습니다.

• 힘 : 1 턴당 최대 HP 10, .5 HP
• 지능 : 턴당 최대 마나 7과 마나 1을줍니다.
• 민첩성 : 회전 지연을 1 감소

움직임, 비전, 범위
범위는 다음과 같습니다 (0을 중심으로). 일부 범위는 추기경 이므로 직접 위, 왼쪽, 오른쪽 또는 아래로만 이동할 수 있습니다.

    444
   43334
  4322234
 432111234
 432101234
 432111234
  4322234
   43334
    444

등장 인물은 2의 시작 비전을 가지고 있습니다.

게임 방법

건설
플레이어는 교제를 구성합니다. 다음 단계를 수행해야합니다 .

1. 각 문자 속성 포인트를 지정하십시오 . 각 캐릭터는 각 스탯에서 5로 시작하고 3 사이에 20을 더 분배합니다.

2. 각 캐릭터에게 능력을 부여하십시오 . 각 캐릭터는 4 개의 능력 슬롯으로 시작하며 기본적으로 능력은 1 슬롯을 사용합니다. 일부 능력은 반복 가능 하며 캐릭터에게 여러 번 주어질 수 있습니다. 소유자의 허가없이 다른 제출 기능을 사용하는 것은 허용되지 않습니다.

3. 봇을위한 코드 를 작성 하십시오. 코드는 Java로 작성되어야하며 전투에 사용됩니다 (다음 단계).

행위

모든 캐릭터는 3 가지 표준 액션으로 시작합니다 :

1. 단계 : 1의 기본 범위에서 캐릭터를 이동
2. 슬라이스 : 기본 범위 1에서 1 차 속성 으로 적 공격
3. 스마일 : 아무것도 하지마

캐릭터 차례에 수행 할 액션을 선택해야합니다. 행동에는 마나가 소모되고 재사용 대기 시간이 생겨 해당 행동을 다시 수행하기 전에 기다려야하는 턴 수를 정의 할 수 있습니다.

능력
모든 캐릭터에는 능력 슬롯이 4 개 있습니다. 이탤릭체로 된 능력이라면 행동입니다.

능력

이름 설명 마나 재사용 대기 시간 
                                                     이동                                                     

깜박임         사각형으로 이동, 범위 4 2 2 
          대상과 스왑 스왑 위치 5 5 
 텔레포트      어디든 이동 20 5

대시 단계의 범위를 1 씩 증가시킵니다.                                               
Mobile Step은 8 방향으로 움직일 수 있습니다                                                  
                                                    공격                                                    

퀵         슬라이스 두 번 3 0 
 직조         보이는 모든 적을 한 번만 슬라이스하십시오 15 10

각 조각을 흡수하면 대상의 기본 특성 중 1 개를 훔칩니다. 20 턴 지속                    
각 조각을 쪼개서 인접한 적에게 1/2의 피해를줍니다.                                           
치명타 슬라이스가 30 %의 확률로 200 %의 피해를 입 힙니다. 반복 가능                               
Feast Each Slice는 HP를 3 증가시킵니다.                                             
8 개 방향 중 어느 방향 으로든 플렉시블 캔 슬라이스                                                      
마나 도둑 조각이 2 마나를 훔칩니다. 반복 가능                                                           
슬라이스시 반사 슬라이스 0 3 
원거리 슬라이스의 범위에 1을 더함                                                              
스 와이프 같은 대상에있는 연속 조각 하나당 마지막보다 3 개의 추가 피해를줍니다.               
                                                    상태                                                     

Dispel        대상에서 모든 상태를 제거합니다. 사거리 2. 20 10 
 결투          당신 중 한 명이 죽을 때까지 당신과 대상을 얼립니다. 범위 1 25 0 
 개편,      당신과 대상이 틱 다음 1000 기절 10 10 
 유성        다음 100 25 10 틱에 대한 모든 적들은 기절 
 가죽 끈         대상은 자신이 다음 턴 동안 4 ~ 6 동결 
 독        5 턴 동안 1 HP에 대한 독 적을 5 0 
 침묵      대상이 5 턴 동안 침묵합니다. 5 7 
 느린          대상이 다음 3 턴 동안 40 틱만큼 느려집니다. 10 5 
 충격          대상이 다음 300 틱 동안 기절합니다. 10 10

추위 2 범위 내의 다른 모든 문자는 10 틱만큼 느려집니다.                                
면역 상태가 적용되지 않습니다                                                           
                                                    방어                                                    

포스 필드   블록 다음 5 가지 피해 원. 하지 스택 (15) 5합니까 
 Ghost를         회전, 모든 피해의 치유 (10) (10) 
 치유          HP 10 3 20 대상을 치유 
 복원       모든 단위는 전체 건강 (20) (40)에 다시 복원 
 쉴드        당신의 다음 턴 때까지 슬라이스를 할 수 없다 3 0

회피가 25 % 확률로 슬라이스가 맞지 않습니다. 반복 가능                                         
기둥 만 한 번만 슬라이스 가능                                                            
부활 죽었을 때 완전한 HP 상태로 상태가 회복됩니다. 
스파이크 데미지를 입었을 때, 데미지의 절반을 되돌립니다                                           
                                                     전망                                                      

망토         팀이 5 턴 동안 보이지 않습니다. 20 20 
 숨기기          5 턴 동안 보이지 않습니다. 4 7 
 단계         1 턴 동안 보이지 않습니다. 0 3 
 트랙         대상이 보이지 않게되어 공격력이 10 %만큼 증가합니다. 10 턴 동안 지속됩니다. 5 5

암흑 적의 시야 범위가 1만큼 감소했습니다.                                 
원거리 시력 범위가 2만큼 증가했습니다.                                                    
보이지 않음 당신은 적의 비전에서 당신의 차례를 시작하면 보이지 않습니다                               
진정한 시야 턴 시작시 범위 2 내의 모든 숨겨진 유닛을 공개합니다                                     
                                                     손해                                                      

드레인은         그들이 한 범위를 유지하면서 5 HP의 대상과 치유자가 5 데미지를 10 5 
 번개     거래 모든 적 20 10-15 손상 
 K / O           대상이 20 % HP 20 0 이하이면 킬 대상 
 트랩          장소 보이지 않는 함정. 함정을 밟으면 함정에 15의 피해를줍니다. 스택. 10 2 
 랩           거래 30 대상에게주는 피해 30 5

정적 1 범위 내의 모든 적에게 1 턴마다 5의 피해를줍니다. 반복 가능                       
                                                      통계                                                      

늑대 인간      5 턴 30 25 모든 통계에 10 추가

버프 HP 풀을 두 배로 늘리십시오. 반복 가능                                                           
영리한 행동의 재사용 대기 시간이 20 % 짧습니다. 반복 가능                                             
집중 마나 회복 속도를 Int / 10만큼 증가시킵니다. 반복 가능                                  
재생 재생력이 2만큼 증가합니다. 반복 가능                                 
현명한 행동은 마나가 2만큼 감소합니다. 반복 가능                                                      
강점 10 특성 포인트를 얻습니다. 반복 가능                                                  
약점 15 점을 잃습니다. 능력 슬롯이 2 개 있습니다 (이 중 하나가 필요합니다)                  
                                                      다른                                                      

곰          캔 각 합계 8 10 5을 가진 곰 소환 
 복제         복제 자신을. 능력 슬롯 2 개를 가져갑니다. 100 100 
 Steal         이 액션을 마지막으로 사용한 적 대상으로 바꿉니다. 지속 10 턴 5 0 
 벽 목표로          지정된 빈 정사각형, 범위 6 10 10에 통과 할 수없는 벽 만들기 

상태 :

• 기절은 캐릭터가 스마일 동작 만 수행하고 X 진드기를 지속 합니다.
• 동결은 캐릭터가 움직이지 못하게하고 X 턴 동안 지속됩니다.
• 침묵은 캐릭터가 스마일, 스텝 또는 슬라이스 이외의 것을 수행하지 못하게하고 X 턴을 지속합니다.
• 독은 Y 턴 동안 X의 피해를 입 힙니다. 다른 독을 적용하면 피해가 합쳐지고 지속 시간이 새로 고쳐집니다.
• 천천히는 턴 사이의 진드기 수에 X를 더합니다. 그것은 다가오는 턴 에는 영향을 미치지 않으며 , 오직 다음 턴에만 영향을줍니다 .
• 보이지 않음으로 인해 상대방이 보거나 손상을 입을 수 없습니다. Step 또는 Smile 이외의 작업을 수행하면 제거됩니다. 상대방에게 당신의 시야를 제공하는 능력이 있다면, 투명성이 제거됩니다.

모든 상태 (독을 제외하고)는 서로 독립적으로 작동합니다.

사이드 노트 :

• 기본 속성과의 연계가 있으면 STR> AGI> INT로 확인됩니다.
• 10x10 그리드에서 재생합니다. 팀은 반대편에 배치됩니다.
• Clever를 제외하고 백분율은 곱셈으로 누적됩니다.

제출 규칙

두 가지 기능을 구현해야합니다.

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

또한 세 가지 변수 (멤버 변수)에 액세스 할 수 있습니다.

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

그게 다야. 아래에서 알파벳순으로 완전한 API를 찾을 수 있습니다.

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

위는 제출에 필요할 수있는 모든 기능입니다. 반사는 허용되지 않습니다. 어떤 이유로 든 제출이 유효하지 않은 경우 제출을 삭제하거나 헤더에 "잘못된"을 추가하십시오. 귀하의 제출은해야 하지 패키지 선언을해야합니다. 제출물은 첫 번째 여러 줄 코드 블록에 포함되어야하며 첫 번째 줄에는 파일 이름이 있어야합니다.

프로젝트를 실행하는 방법 :

몇 가지 방법이 있습니다.

1. JAR 파일을 다운로드 하고 실행하십시오 java -jar Fellowship.jar. 다른 제출물을 다운로드하려면을 전달하십시오 -q 99744. JRE가 아닌 JDK java 를 가리켜 야합니다 .
2. 자식 저장소를 복제 하고 실행하십시오 gradle run. gradle을 설치해야하며 인수를 전달하려면 다음을 사용하십시오.-PappArgs="['arg1', 'args2']"
3. git repo를 복제하고 직접 컴파일하십시오. 당신은 다음 라이브러리가 필요합니다 : 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

복제하는 경우 --recursive플래그 를 사용해야하며 업데이트를 가져올 때--recurse-submodules 다음 중 하나를 포함 하십시오. 클래스 중 하나를 submissions/java폴더 로 이동해야 합니다. gradle을 사용하거나 직접 컴파일하는 경우 클래스를 프로젝트 자체에 넣을 수 있습니다. 주 함수에서 일부 줄의 주석을 해제하고 클래스를 가리 키도록 업데이트해야합니다.

스코어 보드 :

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

질문이 있거나 도움이 필요하면 아래에 의견을 말하거나 대화방에 참여 하십시오 ! 행운을 빌고 재미있게 보내

스태틱 클라우드

가까이 다가오는 사람에게 정적 인 피해를주는 지각있는 성장하는 구름. 다음으로 구성됩니다.

• 1/3 보이지 않는 부분
  • STR : 5; AGI : 5; 지능 : 25
  • 클론 , 보이지 않는 , 정적
• 2/3 보이는 부분
  • STR : 5; AGI : 5; 지능 : 25
  • 클론 , 정적 , 정적

여기에없는 하나 이상의 문자를 추가하는 한 팀에서 여기에서 단일 문자를 재사용 할 수 있습니다.

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

템플릿 플레이어

용도 원거리 , 유연한 , 기력 , 그리고 KO를 . 원하는 경우이 기능 세트를 사용할 권한이 있습니다.

이 봇을 자신 만의 템플릿으로 사용하십시오.

첫 번째 줄에서 파일 이름을 변경하고 고유 한 능력을 선택해야합니다.

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

겁쟁이 스나이퍼 Mk2

사용 써 , FarSight * 2, 숨기기 .

이 봇은 겁쟁이입니다. 최우선 순위는 대상이 아닙니다. 이를 위해 그는 뛰어난 시야를 사용하여 적의 위치를 ​​봅니다. 이 지식을 사용하여 적을 보지 않고 추적 / 추적하는 동안 보이지 않도록합니다. 그것이 보이거나 다음 턴에 보일 수 있다면, 봇은 한동안 보이지 않게 '숨겨 질'것입니다.

추적 모드에서 충분한 마나 및 재사용 대기 시간이 재설정되면 가장 약한 적을 '약탈'합니다.

마나가 10 % 이하로 떨어지면 마나가 회복 될 때까지 적들로부터 멀어집니다. 이런 식으로, 추적 된 적에게 가능한 빨리 뛸 수 있습니다. 적의 HP 재생을 무시합니다.

'Zap'은 무한 범위이므로 팀원은 모두 재핑시 동일한 봇을 대상으로합니다.

나는 대답으로 추가 할 수있는이 동일한 기본 아이디어의 다른 변형을 가지고 있습니다.

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

좀비, 모두가 그들을 알고 있습니다. 그들은 누군가가 나타날 때까지 아무것도하지 않는 그룹에 머물러 있습니다. 그들은 죽이기 어렵고, 당신이 얼마나 많은 사람을 죽이더라도 항상 더 있습니다. 그리고 그들은 보통 등 뒤에서 아무데도 나타나지 않습니다.

• 1 x 좀비 # 1 (가장 강력하고 알파 좀비)
  • STR : 25; AGI : 5; 지능 : 15
  • 클론 , 부활 , 강한
• 2 x 좀비 # 2 (아무도, closing 신용에 좀비 # 3되고 싶어하지, 따라서 모두 같은 번호를 가지고)
  • STR : 15; AGI : 5; 지능 : 15
  • 복제 , 부활 , 흡수

여기에없는 하나 이상의 문자를 추가하는 한 팀에서 여기에서 단일 문자를 재사용 할 수 있습니다.

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

무적

거의 모든 것에서 살아남을 수있는 강력한 전사들로 구성된 팀. 이로 인해 많은 시간 초과가 발생하지만 불행히도 종종 이기지 못합니다. 그러나 내가 본 매치업은 이길 수 없으며 팀이 패배 할 때 캐릭터가 여전히 살아남는 경우가 많습니다.

이 팀의 가장 어려운 경기는 베어 기병대와의 경기입니다 (그들은 문자 그대로이 팀을 닦을 수는 없지만 일반적으로 숫자로 인해 순위 결정에서 승리합니다). Rogue Squad (팀은 독에 약하다); 뱀파이어 (아직 왜 아직 확실하지 않습니다).

시뮬레이션에서 팀은 거의 항상 1 ~ 2 위를 차지합니다. 점수는 꽤 안정적입니다. 우승자는 일반적으로 Rogue Squad가 다른 경쟁자에 비해 얼마나 잘 수행하는지에 달려 있습니다 (이의 배치는 무적의 것보다 훨씬 무작위입니다).

유해한 구체의 마법사

• STR : 5; AGI : 5; 지능 : 25

마법사는 Pillar and Force Field 의 콤보를 사용하여 스스로를 보호합니다 . 집중 되고 과 높은 지능을 가지고, 그 때마다 재사용 대기 시간에 캐스팅 포스 필드에 충분한 마나를 다시 생성합니다. 상대방이 민첩성이 향상되지 않았다고 가정하면 5 턴당 최대 5 개의 조각으로 적을 공격 할 수 있으며이 기간 동안 5 개의 피해 소스가 차단됩니다. 다시 말해, 마법사는 주문을 물리 치기 위해 절대적으로 필요합니다. 당신이 아무리 잘해도 슬라이싱은 그 자체로는 효과가 없습니다.

마법사는 비상시 슬라이싱 (Slicing)을 통해 25 동안 공격 할 수 있지만, 대부분 독을 반복해서 시전 합니다. 포이즌은 팀의 비전에 의해서만 제한되는 무한한 범위를 가지므로 마법사는이 팀이 HP가 무겁거나 회생하는 적을 물리 치는 방식입니다. 나머지 팀은 비전을 유지하고 마법사는 2 차 피해를 입 힙니다. 독은 필연적으로 HP 재생 속도를 앞질렀습니다. 프로세스의 스파이크와 같은 정적 손상에 대해 걱정할 필요가 없습니다.

자이언트 클리프 탑 팔 코너

• STR : 35; AGI : 5; 지능 : 5

Falconer의 주요 임무는 나머지 팀의 목표물을 목표로하여 공격 할 수 있도록 매의 눈으로 맵을 정찰하는 것입니다. 원거리 시력 은 숨기거나 도망치려는 적들이 일반적으로지도 구석에있는 시야 범위에 갇힐 수있는 충분한 시야를 제공합니다. Falconer에게 대안을 제공하는 것은 쉽지 않습니다. True Sight 는 보이지 않는 적들에 대한이 팀의 주요 수단으로, 그렇지 않으면 피해를 줄 수 없습니다. Falconer가 크고 따라서 강력 하면 손상에 매우 강하고 필요할 때 무거운 조각을 만들 수 있습니다. 마지막으로, 팔 코너는 아래의 적군에게 팔콘을 풀어 적들 사이 에 직조 하도록 지시하고 막대한 (35)의 지역 피해를 입 힙니다.

Falconer의 직업은 회피 적을 사냥하고, 마법사가 독을 계속 유지할 수 있도록 적의 시야를 유지하는 것 외에도 가끔 35 명을 짜는 능력이 적군 팀을 상대하는 데 중요합니다. 그런 식으로 많은 적을 공격 할 수 있으며, 팀의 나머지 팀이 완료 할 수있을 정도로 낮은 상태로 둘 수 있습니다 (이상적으로는 다른 직조와 함께). 스 워밍은 이러한 규칙에 따른 강력한 전략이며, 위브 (Wave)는 몇 가지 실제 카운터 중 하나입니다. 그럼에도 불구하고, 그 자체로는 충분하지 않습니다.

트롤 본 스컬 렌더

• STR : 25; AGI : 5; 지능 : 5

트롤 본의 임무는 다른 부대가 임무를 수행하는 동안 적의 무리를 진압하는 것입니다. 마법사와 마찬가지로 트롤 본은 녹아웃 에서 무한한 주문을 사용 합니다. 이것은 마법사의 독과 아주 잘 어울립니다. 적을 하나씩 상대 할 수 있다면 (그리고 많은 팀과 맞서면), 팔 코너는 비전을 얻고, 트롤 본은 그들을 기절시키고, 마법사는 그들에게 독을 쌓아 죽게됩니다. 아무 것도 할 수있는 능력없이 (녹아웃은 대상에서 1000 틱을 지속하고 트롤 본은 재사용 대기 시간을 약간 빠르게 회복합니다). 또한 하나의 강한 적들로부터 트롤 본을 보호하는 데 아주 좋습니다. 그들은 의식이 없으면 그에게 아무것도 할 수 없습니다. 물론, 적과 함께 해골을 때리는 것은 두 가지 뇌진탕을 남기고기절시키고 독에 중독시키는 것 (그리고 아무도 신경 쓰지 않는 다른 상태들). 그럼에도 불구하고 트롤 본은 마법에 사로 잡히지 않는 마법에 집중된 캐릭터로서 지능을 통해서가 아니라 적의 피를 마시면서 적을 때마다 마나 훔치기 를 통해 마법을 재생합니다 . 이것은 꽤 좋은 MP 재생 속도를 제공합니다 (그리고 기절 한 적들은 MP를 훔치기 쉬운 대상으로 만듭니다). 마지막으로, Trollbone 가끔 미쳐가는 것 위브 에 머리를 부딪 히고 그들의 피를 마시는 동안 적의 계급을 통해서. 충분히 큰 적 무리에 대항하여, 이것은 실제로 마나를 회복하며, 팔 코너가 약해진 무리를 마무리 짓습니다 (25 + 35는 60이므로 적들이 그 사이에 어느 정도 재생 되더라도 작동합니다).

전략

많은 팀과 달리 팀 구축뿐만 아니라 AI에도 많은 관심을 기울였습니다. 기본 규칙 중 하나는 팀이 다른 일을 하느라 바쁘지 않으면 항상 그룹화를 시도하여 서로 포위하고 서로를 방어하기가 더 어렵다는 것입니다. 그들이 무리를 짓고 있다면, 그들은 모퉁이에 숨기려고 노력할 것입니다. 반면에 적군이 도망 치거나 도망 가려고하면지도를 돌아 다니며 무작위 구석이나 중앙으로 이동합니다. 이것은 Falconer가 결국 목표를 발견 할 것임을 보증합니다. 이 운동은 가능한 경우 적이 첫 번째 공격을받지 않도록 설계되었습니다. 적은 슬라이스 범위로 들어가야합니다. 마법사는 항상힘 소진을 위해 MP를 남겨두면 MP 소진으로 인한 손실을 막을 수 있습니다. (실패 할 수있는 유일한 방법은 피해를 입지 않아도 포스 필드를 통과 할 수있는 Absorb입니다.) 이것은 일반적으로 문제가되지 않습니다. 일반적으로 마법사는 매 턴마다 아무 문제없이 독을 스팸으로 분류 할 수 있습니다. 방해받지 않으면 팀은 적을 한 번에 하나씩 추격하여 시력에 들어올 때 기절시킨 다음 죽을 때까지 반복적으로 중독시키는 것을 선호합니다. 주변의 다른 적들과 함께, 팀은 가능하다면 연을 날 리려고 노력하며, 원을 그리며 뛰어 다니며 대부분의 적을 쫓아 내며, 적 중 하나를 놀라게하고 중독시킵니다. 주요 문제는 무리에 관한 것이므로 여기에 직물이 너무 많지만 실제로 전략을이기는 것은 어려워 보입니다.

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

도적 분대

불량 팀은 다음과 같이 구성됩니다.

• 1 정찰병 (지도를 탐색하는 동안 그림자에 머물러 있습니다)
  • STR : 5; AGI : 5; 지능 : 25
  • 클론 , 보이지 않는 , 원거리
• 암살자 2 명 (치명적인 독으로 적을 공격)
  • STR : 5; AGI : 5; 지능 : 25
  • 클론 , 독 , 집중

둘 다 사용할 수있는 가장 큰 힘은 분대원을 불러서 지원하는 것입니다.

여기에없는 하나 이상의 문자를 추가하는 한 팀에서 여기에서 단일 문자를 재사용 할 수 있습니다.

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

모든 봇의 기본 클래스

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